1 /* SPDX-License-Identifier: GPL-2.0 */
2 /******************************************************************************
3 *
4 * Copyright(c) 2016 - 2017 Realtek Corporation.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 *****************************************************************************/
16
17 /* ************************************************************
18 * Description:
19 *
20 * This file is for RTL8723B Co-exist mechanism
21 *
22 * History
23 * 2012/11/15 Cosa first check in.
24 *
25 * ************************************************************ */
26
27 /* ************************************************************
28 * include files
29 * ************************************************************ */
30 #include "mp_precomp.h"
31
32 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
33
34 #if (RTL8723B_SUPPORT == 1)
35 /* ************************************************************
36 * Global variables, these are static variables
37 * ************************************************************ */
38 static u8 *trace_buf = &gl_btc_trace_buf[0];
39 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant;
40 static struct coex_dm_8723b_1ant *coex_dm = &glcoex_dm_8723b_1ant;
41 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant;
42 static struct coex_sta_8723b_1ant *coex_sta = &glcoex_sta_8723b_1ant;
43 static struct psdscan_sta_8723b_1ant gl_psd_scan_8723b_1ant;
44 static struct psdscan_sta_8723b_1ant *psd_scan = &gl_psd_scan_8723b_1ant;
45
46
47 const char *const glbt_info_src_8723b_1ant[] = {
48 "BT Info[wifi fw]",
49 "BT Info[bt rsp]",
50 "BT Info[bt auto report]",
51 };
52
53 u32 glcoex_ver_date_8723b_1ant = 20180201;
54 u32 glcoex_ver_8723b_1ant = 0x6f;
55 u32 glcoex_ver_btdesired_8723b_1ant = 0x6d;
56
57 /* ************************************************************
58 * local function proto type if needed
59 * ************************************************************
60 * ************************************************************
61 * local function start with halbtc8723b1ant_
62 * ************************************************************ */
63 static
halbtc8723b1ant_update_ra_mask(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u32 dis_rate_mask)64 void halbtc8723b1ant_update_ra_mask(IN struct btc_coexist *btcoexist,
65 IN boolean force_exec, IN u32 dis_rate_mask)
66 {
67 coex_dm->cur_ra_mask = dis_rate_mask;
68
69 if (force_exec || (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask))
70 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
71 &coex_dm->cur_ra_mask);
72 coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
73 }
74
75 static
halbtc8723b1ant_auto_rate_fallback_retry(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)76 void halbtc8723b1ant_auto_rate_fallback_retry(IN struct btc_coexist *btcoexist,
77 IN boolean force_exec, IN u8 type)
78 {
79 boolean wifi_under_b_mode = false;
80
81 coex_dm->cur_arfr_type = type;
82
83 if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
84 switch (coex_dm->cur_arfr_type) {
85 case 0: /* normal mode */
86 btcoexist->btc_write_4byte(btcoexist, 0x430,
87 coex_dm->backup_arfr_cnt1);
88 btcoexist->btc_write_4byte(btcoexist, 0x434,
89 coex_dm->backup_arfr_cnt2);
90 break;
91 case 1:
92 btcoexist->btc_get(btcoexist,
93 BTC_GET_BL_WIFI_UNDER_B_MODE,
94 &wifi_under_b_mode);
95 if (wifi_under_b_mode) {
96 btcoexist->btc_write_4byte(btcoexist,
97 0x430, 0x0);
98 btcoexist->btc_write_4byte(btcoexist,
99 0x434, 0x01010101);
100 } else {
101 btcoexist->btc_write_4byte(btcoexist,
102 0x430, 0x0);
103 btcoexist->btc_write_4byte(btcoexist,
104 0x434, 0x04030201);
105 }
106 break;
107 default:
108 break;
109 }
110 }
111
112 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
113 }
114
115 static
halbtc8723b1ant_retry_limit(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)116 void halbtc8723b1ant_retry_limit(IN struct btc_coexist *btcoexist,
117 IN boolean force_exec, IN u8 type)
118 {
119 coex_dm->cur_retry_limit_type = type;
120
121 if (force_exec ||
122 (coex_dm->pre_retry_limit_type !=
123 coex_dm->cur_retry_limit_type)) {
124 switch (coex_dm->cur_retry_limit_type) {
125 case 0: /* normal mode */
126 btcoexist->btc_write_2byte(btcoexist, 0x42a,
127 coex_dm->backup_retry_limit);
128 break;
129 case 1: /* retry limit=8 */
130 btcoexist->btc_write_2byte(btcoexist, 0x42a,
131 0x0808);
132 break;
133 default:
134 break;
135 }
136 }
137
138 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
139 }
140
141 static
halbtc8723b1ant_ampdu_max_time(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)142 void halbtc8723b1ant_ampdu_max_time(IN struct btc_coexist *btcoexist,
143 IN boolean force_exec, IN u8 type)
144 {
145 coex_dm->cur_ampdu_time_type = type;
146
147 if (force_exec ||
148 (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
149 switch (coex_dm->cur_ampdu_time_type) {
150 case 0: /* normal mode */
151 btcoexist->btc_write_1byte(btcoexist, 0x456,
152 coex_dm->backup_ampdu_max_time);
153 break;
154 case 1: /* AMPDU timw = 0x38 * 32us */
155 btcoexist->btc_write_1byte(btcoexist, 0x456,
156 0x38);
157 break;
158 default:
159 break;
160 }
161 }
162
163 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
164 }
165
166 static
halbtc8723b1ant_limited_tx(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 ra_mask_type,IN u8 arfr_type,IN u8 retry_limit_type,IN u8 ampdu_time_type)167 void halbtc8723b1ant_limited_tx(IN struct btc_coexist *btcoexist,
168 IN boolean force_exec, IN u8 ra_mask_type, IN u8 arfr_type,
169 IN u8 retry_limit_type, IN u8 ampdu_time_type)
170 {
171 switch (ra_mask_type) {
172 case 0: /* normal mode */
173 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
174 0x0);
175 break;
176 case 1: /* disable cck 1/2 */
177 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
178 0x00000003);
179 break;
180 case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
181 halbtc8723b1ant_update_ra_mask(btcoexist, force_exec,
182 0x0001f1f7);
183 break;
184 default:
185 break;
186 }
187
188 halbtc8723b1ant_auto_rate_fallback_retry(btcoexist, force_exec,
189 arfr_type);
190 halbtc8723b1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
191 halbtc8723b1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
192 }
193
194 static
halbtc8723b1ant_limited_rx(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean rej_ap_agg_pkt,IN boolean bt_ctrl_agg_buf_size,IN u8 agg_buf_size)195 void halbtc8723b1ant_limited_rx(IN struct btc_coexist *btcoexist,
196 IN boolean force_exec, IN boolean rej_ap_agg_pkt,
197 IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
198 {
199 boolean reject_rx_agg = rej_ap_agg_pkt;
200 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
201 u8 rx_agg_size = agg_buf_size;
202
203 /* ============================================ */
204 /* Rx Aggregation related setting */
205 /* ============================================ */
206 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
207 &reject_rx_agg);
208 /* decide BT control aggregation buf size or not */
209 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
210 &bt_ctrl_rx_agg_size);
211 /* aggregation buf size, only work when BT control Rx aggregation size. */
212 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
213 /* real update aggregation setting */
214 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
215
216
217 }
218
219 static
halbtc8723b1ant_query_bt_info(IN struct btc_coexist * btcoexist)220 void halbtc8723b1ant_query_bt_info(IN struct btc_coexist *btcoexist)
221 {
222 u8 h2c_parameter[1] = {0};
223
224 coex_sta->c2h_bt_info_req_sent = true;
225
226 h2c_parameter[0] |= BIT(0); /* trigger */
227
228 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
229 }
230
231 static
halbtc8723b1ant_monitor_bt_ctr(IN struct btc_coexist * btcoexist)232 void halbtc8723b1ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
233 {
234 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
235 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
236 static u32 num_of_bt_counter_chk = 0;
237 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
238
239 /* to avoid 0x76e[3] = 1 (WLAN_Act control by PTA) during IPS */
240 /* if (! (btcoexist->btc_read_1byte(btcoexist, 0x76e) & 0x8) ) */
241
242 reg_hp_txrx = 0x770;
243 reg_lp_txrx = 0x774;
244
245 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
246 reg_hp_tx = u32tmp & MASKLWORD;
247 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
248
249 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
250 reg_lp_tx = u32tmp & MASKLWORD;
251 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
252
253 coex_sta->high_priority_tx = reg_hp_tx;
254 coex_sta->high_priority_rx = reg_hp_rx;
255 coex_sta->low_priority_tx = reg_lp_tx;
256 coex_sta->low_priority_rx = reg_lp_rx;
257
258 if ((coex_sta->low_priority_tx > 1050) &&
259 (!coex_sta->c2h_bt_inquiry_page))
260 coex_sta->pop_event_cnt++;
261
262 if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips)
263 && (coex_sta->low_priority_rx >=
264 coex_sta->low_priority_tx) &&
265 (!coex_sta->c2h_bt_inquiry_page))
266 bt_link_info->slave_role = true;
267 else
268 bt_link_info->slave_role = false;
269
270 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
271 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
272 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
273 BTC_TRACE(trace_buf);
274
275 /* reset counter */
276 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
277
278 /* This part is for wifi FW and driver to update BT's status as disabled. */
279 /* The flow is as the following */
280 /* 1. disable BT */
281 /* 2. if all BT Tx/Rx counter=0, after 6 sec we query bt info */
282 /* 3. Because BT will not rsp from mailbox, so wifi fw will know BT is disabled */
283 /* 4. FW will rsp c2h for BT that driver will know BT is disabled. */
284 if ((reg_hp_tx == 0) && (reg_hp_rx == 0) && (reg_lp_tx == 0) &&
285 (reg_lp_rx == 0)) {
286 num_of_bt_counter_chk++;
287 if (num_of_bt_counter_chk >= 3) {
288 halbtc8723b1ant_query_bt_info(btcoexist);
289 num_of_bt_counter_chk = 0;
290 }
291 }
292
293 }
294
295 static
halbtc8723b1ant_monitor_wifi_ctr(IN struct btc_coexist * btcoexist)296 void halbtc8723b1ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
297 {
298 s32 wifi_rssi = 0;
299 boolean wifi_busy = false, wifi_under_b_mode = false;
300 static u8 cck_lock_counter = 0;
301 u32 total_cnt;
302
303 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
304 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
305 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
306 &wifi_under_b_mode);
307
308 #if 1
309
310 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
311 btcoexist,
312 PHYDM_INFO_CRC32_OK_CCK);
313 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
314 btcoexist,
315 PHYDM_INFO_CRC32_OK_LEGACY);
316 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
317 btcoexist,
318 PHYDM_INFO_CRC32_OK_HT);
319 coex_sta->crc_ok_11n_vht =
320 btcoexist->btc_phydm_query_PHY_counter(
321 btcoexist,
322 PHYDM_INFO_CRC32_OK_VHT);
323
324 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
325 btcoexist,
326 PHYDM_INFO_CRC32_ERROR_CCK);
327 coex_sta->crc_err_11g = btcoexist->btc_phydm_query_PHY_counter(
328 btcoexist,
329 PHYDM_INFO_CRC32_ERROR_LEGACY);
330 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
331 btcoexist,
332 PHYDM_INFO_CRC32_ERROR_HT);
333 coex_sta->crc_err_11n_vht =
334 btcoexist->btc_phydm_query_PHY_counter(
335 btcoexist,
336 PHYDM_INFO_CRC32_ERROR_VHT);
337
338 #endif
339
340 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
341 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
342 coex_sta->crc_ok_11n +
343 coex_sta->crc_ok_11n_vht;
344
345 if ((coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
346 (coex_dm->bt_status ==
347 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
348 (coex_dm->bt_status ==
349 BT_8723B_1ANT_BT_STATUS_SCO_BUSY)) {
350 if (coex_sta->crc_ok_cck > (total_cnt -
351 coex_sta->crc_ok_cck)) {
352 if (cck_lock_counter < 3)
353 cck_lock_counter++;
354 } else {
355 if (cck_lock_counter > 0)
356 cck_lock_counter--;
357 }
358
359 } else {
360 if (cck_lock_counter > 0)
361 cck_lock_counter--;
362 }
363 } else {
364 if (cck_lock_counter > 0)
365 cck_lock_counter--;
366 }
367
368 if (!coex_sta->pre_ccklock) {
369
370 if (cck_lock_counter >= 3)
371 coex_sta->cck_lock = true;
372 else
373 coex_sta->cck_lock = false;
374 } else {
375 if (cck_lock_counter == 0)
376 coex_sta->cck_lock = false;
377 else
378 coex_sta->cck_lock = true;
379 }
380
381 if (coex_sta->cck_lock)
382 coex_sta->cck_ever_lock = true;
383
384 coex_sta->pre_ccklock = coex_sta->cck_lock;
385
386
387 }
388
389 static
halbtc8723b1ant_is_wifi_status_changed(IN struct btc_coexist * btcoexist)390 boolean halbtc8723b1ant_is_wifi_status_changed(IN struct btc_coexist *btcoexist)
391 {
392 static boolean pre_wifi_busy = false, pre_under_4way = false,
393 pre_bt_hs_on = false;
394 boolean wifi_busy = false, under_4way = false, bt_hs_on = false;
395 boolean wifi_connected = false;
396
397 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
398 &wifi_connected);
399 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
400 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
401 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
402 &under_4way);
403
404 if (wifi_connected) {
405 if (wifi_busy != pre_wifi_busy) {
406 pre_wifi_busy = wifi_busy;
407 return true;
408 }
409 if (under_4way != pre_under_4way) {
410 pre_under_4way = under_4way;
411 return true;
412 }
413 if (bt_hs_on != pre_bt_hs_on) {
414 pre_bt_hs_on = bt_hs_on;
415 return true;
416 }
417
418
419 }
420
421 return false;
422 }
423
424 static
halbtc8723b1ant_monitor_bt_enable_disable(IN struct btc_coexist * btcoexist)425 void halbtc8723b1ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
426 {
427 static u32 bt_disable_cnt = 0;
428 boolean bt_active = true, bt_disabled = false, bt_change = false;
429
430 /* This function check if bt is disabled */
431
432 if (coex_sta->high_priority_tx == 0 &&
433 coex_sta->high_priority_rx == 0 &&
434 coex_sta->low_priority_tx == 0 &&
435 coex_sta->low_priority_rx == 0)
436 bt_active = false;
437 if (coex_sta->high_priority_tx == 0xffff &&
438 coex_sta->high_priority_rx == 0xffff &&
439 coex_sta->low_priority_tx == 0xffff &&
440 coex_sta->low_priority_rx == 0xffff)
441 bt_active = false;
442 if (bt_active) {
443 bt_disable_cnt = 0;
444 bt_disabled = false;
445 } else {
446 bt_disable_cnt++;
447 if (bt_disable_cnt >= 10)
448 bt_disabled = true;
449 }
450 if (coex_sta->bt_disabled != bt_disabled) {
451 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
452 "[BTCoex], BT is from %s to %s!!\n",
453 (coex_sta->bt_disabled ? "disabled" : "enabled"),
454 (bt_disabled ? "disabled" : "enabled"));
455 BTC_TRACE(trace_buf);
456 bt_change = true;
457
458 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
459 &bt_disabled);
460
461 btcoexist->btc_set(btcoexist,
462 BTC_SET_BL_BT_ENABLE_DISABLE_CHANGE,
463 &bt_change);
464
465 coex_sta->bt_disabled = bt_disabled;
466 } else {
467 btcoexist->btc_set(btcoexist,
468 BTC_SET_BL_BT_ENABLE_DISABLE_CHANGE,
469 &bt_change);
470 }
471 }
472
473 static
halbtc8723b1ant_update_bt_link_info(IN struct btc_coexist * btcoexist)474 void halbtc8723b1ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
475 {
476 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
477 boolean bt_hs_on = false;
478
479 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
480
481 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
482 bt_link_info->sco_exist = coex_sta->sco_exist;
483 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
484 bt_link_info->pan_exist = coex_sta->pan_exist;
485 bt_link_info->hid_exist = coex_sta->hid_exist;
486 bt_link_info->bt_hi_pri_link_exist = coex_sta->bt_hi_pri_link_exist;
487
488 /* work around for HS mode. */
489 if (bt_hs_on) {
490 bt_link_info->pan_exist = true;
491 bt_link_info->bt_link_exist = true;
492 }
493
494 /* check if Sco only */
495 if (bt_link_info->sco_exist &&
496 !bt_link_info->a2dp_exist &&
497 !bt_link_info->pan_exist &&
498 !bt_link_info->hid_exist)
499 bt_link_info->sco_only = true;
500 else
501 bt_link_info->sco_only = false;
502
503 /* check if A2dp only */
504 if (!bt_link_info->sco_exist &&
505 bt_link_info->a2dp_exist &&
506 !bt_link_info->pan_exist &&
507 !bt_link_info->hid_exist)
508 bt_link_info->a2dp_only = true;
509 else
510 bt_link_info->a2dp_only = false;
511
512 /* check if Pan only */
513 if (!bt_link_info->sco_exist &&
514 !bt_link_info->a2dp_exist &&
515 bt_link_info->pan_exist &&
516 !bt_link_info->hid_exist)
517 bt_link_info->pan_only = true;
518 else
519 bt_link_info->pan_only = false;
520
521 /* check if Hid only */
522 if (!bt_link_info->sco_exist &&
523 !bt_link_info->a2dp_exist &&
524 !bt_link_info->pan_exist &&
525 bt_link_info->hid_exist)
526 bt_link_info->hid_only = true;
527 else
528 bt_link_info->hid_only = false;
529 }
530
531 static
halbtc8723b1ant_set_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean enable_auto_report)532 void halbtc8723b1ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
533 IN boolean enable_auto_report)
534 {
535 u8 h2c_parameter[1] = {0};
536
537 h2c_parameter[0] = 0;
538
539 if (enable_auto_report)
540 h2c_parameter[0] |= BIT(0);
541
542 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
543 }
544
545 static
halbtc8723b1ant_bt_auto_report(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable_auto_report)546 void halbtc8723b1ant_bt_auto_report(IN struct btc_coexist *btcoexist,
547 IN boolean force_exec, IN boolean enable_auto_report)
548 {
549 coex_dm->cur_bt_auto_report = enable_auto_report;
550
551 if (!force_exec) {
552 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
553 return;
554 }
555 halbtc8723b1ant_set_bt_auto_report(btcoexist,
556 coex_dm->cur_bt_auto_report);
557
558 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
559 }
560
561 static
halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(IN struct btc_coexist * btcoexist,IN boolean low_penalty_ra)562 void halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(IN struct btc_coexist
563 *btcoexist, IN boolean low_penalty_ra)
564 {
565 u8 h2c_parameter[6] = {0};
566
567 h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
568
569 if (low_penalty_ra) {
570 h2c_parameter[1] |= BIT(0);
571 h2c_parameter[2] =
572 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
573 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
574 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
575 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
576 }
577
578 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
579 }
580
581 static
halbtc8723b1ant_low_penalty_ra(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean low_penalty_ra)582 void halbtc8723b1ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
583 IN boolean force_exec, IN boolean low_penalty_ra)
584 {
585 coex_dm->cur_low_penalty_ra = low_penalty_ra;
586
587 if (!force_exec) {
588 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
589 return;
590 }
591 halbtc8723b1ant_set_sw_penalty_tx_rate_adaptive(btcoexist,
592 coex_dm->cur_low_penalty_ra);
593
594 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
595 }
596
597 static
halbtc8723b1ant_sw_mechanism(IN struct btc_coexist * btcoexist,IN boolean low_penalty_ra)598 void halbtc8723b1ant_sw_mechanism(IN struct btc_coexist *btcoexist,
599 IN boolean low_penalty_ra)
600 {
601 halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
602 }
603
604 static
halbtc8723b1ant_coex_table(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u32 val0x6c0,IN u32 val0x6c4,IN u32 val0x6c8,IN u8 val0x6cc)605 void halbtc8723b1ant_coex_table(IN struct btc_coexist *btcoexist,
606 IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
607 IN u32 val0x6c8, IN u8 val0x6cc)
608 {
609
610 if (!force_exec) {
611 if ((val0x6c0 == coex_dm->cur_val0x6c0) &&
612 (val0x6c4 == coex_dm->cur_val0x6c4) &&
613 (val0x6c8 == coex_dm->cur_val0x6c8) &&
614 (val0x6cc == coex_dm->cur_val0x6cc))
615 return;
616 }
617
618 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
619 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
620 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
621 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
622
623 coex_dm->cur_val0x6c0 = val0x6c0;
624 coex_dm->cur_val0x6c4 = val0x6c4;
625 coex_dm->cur_val0x6c8 = val0x6c8;
626 coex_dm->cur_val0x6cc = val0x6cc;
627
628 }
629
630 static
halbtc8723b1ant_coex_table_with_type(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 type)631 void halbtc8723b1ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
632 IN boolean force_exec, IN u8 type)
633 {
634 struct btc_board_info *board_info = &btcoexist->board_info;
635
636 #if BT_8723B_1ANT_ANTDET_ENABLE
637 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
638 if (board_info->btdm_ant_num_by_ant_det == 2) {
639 if (type == 3)
640 type = 14;
641 else if (type == 4)
642 type = 13;
643 else if (type == 5)
644 type = 8;
645 }
646 #endif
647 #endif
648
649 coex_sta->coex_table_type = type;
650
651 switch (type) {
652 case 0:
653 halbtc8723b1ant_coex_table(btcoexist, force_exec,
654 0x55555555, 0x55555555, 0xffffff, 0x3);
655 break;
656 case 1:
657 halbtc8723b1ant_coex_table(btcoexist, force_exec,
658 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3);
659 break;
660 case 2:
661 halbtc8723b1ant_coex_table(btcoexist, force_exec,
662 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3);
663 break;
664 case 3:
665 halbtc8723b1ant_coex_table(btcoexist, force_exec,
666 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3);
667 break;
668 case 4:
669 if ((coex_sta->cck_ever_lock) &&
670 (coex_sta->scan_ap_num <= 5))
671 halbtc8723b1ant_coex_table(btcoexist,
672 force_exec, 0x55555555, 0xaaaa5a5a,
673 0xffffff, 0x3);
674 else
675 halbtc8723b1ant_coex_table(btcoexist,
676 force_exec, 0x55555555, 0x5a5a5a5a,
677 0xffffff, 0x3);
678 break;
679 case 5:
680 if ((coex_sta->cck_ever_lock) &&
681 (coex_sta->scan_ap_num <= 5))
682 halbtc8723b1ant_coex_table(btcoexist,
683 force_exec, 0x5a5a5a5a, 0x5aaa5a5a,
684 0xffffff, 0x3);
685 else
686 halbtc8723b1ant_coex_table(btcoexist,
687 force_exec, 0x5a5a5a5a, 0x5aaa5a5a,
688 0xffffff, 0x3);
689 break;
690 case 6:
691 halbtc8723b1ant_coex_table(btcoexist, force_exec,
692 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3);
693 break;
694 case 7:
695 halbtc8723b1ant_coex_table(btcoexist, force_exec,
696 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3);
697 break;
698 case 8:
699 halbtc8723b1ant_coex_table(btcoexist, force_exec,
700 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
701 break;
702 case 9:
703 halbtc8723b1ant_coex_table(btcoexist, force_exec,
704 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
705 break;
706 case 10:
707 halbtc8723b1ant_coex_table(btcoexist, force_exec,
708 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
709 break;
710 case 11:
711 halbtc8723b1ant_coex_table(btcoexist, force_exec,
712 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
713 break;
714 case 12:
715 halbtc8723b1ant_coex_table(btcoexist, force_exec,
716 0x55dd55dd, 0x5ada5ada, 0xffffff, 0x3);
717 break;
718 case 13:
719 halbtc8723b1ant_coex_table(btcoexist, force_exec,
720 0x5fff5fff, 0xaaaaaaaa, 0xffffff, 0x3);
721 break;
722 case 14:
723 halbtc8723b1ant_coex_table(btcoexist, force_exec,
724 0x5fff5fff, 0x5ada5ada, 0xffffff, 0x3);
725 break;
726 case 15:
727 halbtc8723b1ant_coex_table(btcoexist, force_exec,
728 0x55dd55dd, 0xaaaaaaaa, 0xffffff, 0x3);
729 break;
730 case 16:
731 halbtc8723b1ant_coex_table(btcoexist,
732 force_exec, 0x55555555, 0x5a5a5aaa,
733 0xffffff, 0x3);
734 break;
735 case 17:
736 halbtc8723b1ant_coex_table(btcoexist,
737 force_exec, 0x55555555, 0xaaaa5aaa,
738 0xffffff, 0x3);
739 break;
740 case 18:
741 halbtc8723b1ant_coex_table(btcoexist,
742 force_exec, 0x55555555, 0x5a5a5a6a,
743 0xffffff, 0x3);
744 break;
745 case 19:
746 halbtc8723b1ant_coex_table(btcoexist,
747 force_exec, 0xa5555555, 0x5a5a5a5a,
748 0xffffff, 0x3);
749 break;
750 case 20:
751 halbtc8723b1ant_coex_table(btcoexist,
752 force_exec, 0xaa555555, 0xaa555555,
753 0xffffff, 0x3);
754 break;
755 case 21:
756 halbtc8723b1ant_coex_table(btcoexist,
757 force_exec, 0xaa5a5a5a, 0xaa5a5a5a,
758 0xffffff, 0x3);
759 break;
760 case 22:
761 halbtc8723b1ant_coex_table(btcoexist,
762 force_exec, 0xaa5555aa, 0x5a5a5a5a,
763 0xffffff, 0x3);
764 break;
765 case 23:
766 halbtc8723b1ant_coex_table(btcoexist,
767 force_exec, 0x55555555, 0xaaaa5a5a,
768 0xffffff, 0x3);
769 break;
770 default:
771 break;
772 }
773 }
774
775 static
halbtc8723b1ant_set_wltoggle_coex_table(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 interval,IN u8 val0x6c4_b0,IN u8 val0x6c4_b1,IN u8 val0x6c4_b2,IN u8 val0x6c4_b3)776 void halbtc8723b1ant_set_wltoggle_coex_table(IN struct btc_coexist *btcoexist,
777 IN boolean force_exec, IN u8 interval,
778 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1, IN u8 val0x6c4_b2,
779 IN u8 val0x6c4_b3)
780 {
781 static u8 pre_h2c_parameter[6] = {0};
782 u8 cur_h2c_parameter[6] = {0};
783 u8 i, match_cnt = 0;
784
785 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
786
787 cur_h2c_parameter[1] = interval;
788 cur_h2c_parameter[2] = val0x6c4_b0;
789 cur_h2c_parameter[3] = val0x6c4_b1;
790 cur_h2c_parameter[4] = val0x6c4_b2;
791 cur_h2c_parameter[5] = val0x6c4_b3;
792
793 if (!force_exec) {
794 for (i = 1; i <= 5; i++) {
795 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
796 break;
797
798 match_cnt++;
799 }
800
801 if (match_cnt == 5)
802 return;
803 }
804
805 for (i = 1; i <= 5; i++)
806 pre_h2c_parameter[i] = cur_h2c_parameter[i];
807
808 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
809 }
810
811 static
halbtc8723b1ant_set_fw_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean enable)812 void halbtc8723b1ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
813 IN boolean enable)
814 {
815 u8 h2c_parameter[1] = {0};
816
817 if (enable)
818 h2c_parameter[0] |= BIT(0); /* function enable */
819
820 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
821 }
822
823 static
halbtc8723b1ant_ignore_wlan_act(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean enable)824 void halbtc8723b1ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
825 IN boolean force_exec, IN boolean enable)
826 {
827 coex_dm->cur_ignore_wlan_act = enable;
828
829 if (!force_exec) {
830 if (coex_dm->pre_ignore_wlan_act ==
831 coex_dm->cur_ignore_wlan_act)
832 return;
833 }
834 halbtc8723b1ant_set_fw_ignore_wlan_act(btcoexist, enable);
835
836 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
837 }
838
839 static
halbtc8723b1ant_set_lps_rpwm(IN struct btc_coexist * btcoexist,IN u8 lps_val,IN u8 rpwm_val)840 void halbtc8723b1ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
841 IN u8 lps_val, IN u8 rpwm_val)
842 {
843 u8 lps = lps_val;
844 u8 rpwm = rpwm_val;
845
846 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
847 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
848 }
849
850 static
halbtc8723b1ant_lps_rpwm(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN u8 lps_val,IN u8 rpwm_val)851 void halbtc8723b1ant_lps_rpwm(IN struct btc_coexist *btcoexist,
852 IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
853 {
854 coex_dm->cur_lps = lps_val;
855 coex_dm->cur_rpwm = rpwm_val;
856
857 if (!force_exec) {
858 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
859 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
860 return;
861 }
862 halbtc8723b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
863
864 coex_dm->pre_lps = coex_dm->cur_lps;
865 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
866 }
867
868 static
halbtc8723b1ant_set_ant_path(IN struct btc_coexist * btcoexist,IN u8 ant_pos_type,IN boolean force_exec,IN boolean init_hwcfg,IN boolean wifi_off)869 void halbtc8723b1ant_set_ant_path(IN struct btc_coexist *btcoexist,
870 IN u8 ant_pos_type, IN boolean force_exec, IN boolean init_hwcfg,
871 IN boolean wifi_off)
872 {
873 struct btc_board_info *board_info = &btcoexist->board_info;
874 u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0;
875 boolean pg_ext_switch = false;
876 boolean use_ext_switch = false;
877 boolean is_in_mp_mode = false;
878 u8 h2c_parameter[2] = {0}, u8tmp = 0, u8tmpa = 0, u8tmpb = 0;
879 u32 u32tmp_1[4];
880 boolean is_fw_ready;
881
882 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
883 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
884 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
885
886 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
887 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x (before set ant path)\n",
888 u32tmp, u8tmpa, u8tmpb);
889 BTC_TRACE(trace_buf);
890
891 coex_dm->cur_ant_pos_type = ant_pos_type;
892
893 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
894 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER,
895 &fw_ver); /* [31:16]=fw ver, [15:0]=fw sub ver */
896
897 if ((fw_ver > 0 && fw_ver < 0xc0000) || pg_ext_switch)
898 use_ext_switch = true;
899
900 #if BT_8723B_1ANT_ANTDET_ENABLE
901 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
902 if (ant_pos_type == BTC_ANT_PATH_PTA) {
903 if ((board_info->btdm_ant_det_finish) &&
904 (board_info->btdm_ant_num_by_ant_det == 2)) {
905 if (board_info->btdm_ant_pos ==
906 BTC_ANTENNA_AT_MAIN_PORT)
907 ant_pos_type = BTC_ANT_PATH_WIFI;
908 else
909 ant_pos_type = BTC_ANT_PATH_BT;
910 }
911 }
912 #endif
913 #endif
914
915 if (init_hwcfg) {
916 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
917 0x780); /* WiFi TRx Mask on */
918 /* remove due to interrupt is disabled that polling c2h will fail and delay 100ms. */
919 /* btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x15); */ /*BT TRx Mask on */
920
921 if (fw_ver >= 0x180000) {
922 /* Use H2C to set GNT_BT to HIGH */
923 h2c_parameter[0] = 1;
924 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
925 h2c_parameter);
926
927 cnt_bt_cal_chk = 0;
928 while (1) {
929 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_FW_READY, &is_fw_ready);
930 if (is_fw_ready == false) {
931 BTC_SPRINTF(trace_buf , BT_TMP_BUF_SIZE,
932 ("halbtc8723b1ant_set_ant_path(): we don't need to wait for H2C command completion because of Fw download fail!!!\n"));
933 BTC_TRACE(trace_buf);
934 break;
935 }
936
937 if (btcoexist->btc_read_1byte(btcoexist,
938 0x765) == 0x18)
939 break;
940
941 cnt_bt_cal_chk++;
942 if (cnt_bt_cal_chk > 20)
943 break;
944 }
945 } else {
946 /* set grant_bt to high */
947 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
948 }
949 /* set wlan_act control by PTA */
950 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
951
952 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
953 0x0); /* BT select s0/s1 is controlled by BT */
954
955 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
956 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
957 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
958 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
959 } else if (wifi_off) {
960 if (fw_ver >= 0x180000) {
961 /* Use H2C to set GNT_BT to HIGH */
962 h2c_parameter[0] = 1;
963 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
964 h2c_parameter);
965
966 cnt_bt_cal_chk = 0;
967 while (1) {
968 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_FW_READY, &is_fw_ready);
969 if (is_fw_ready == false) {
970 BTC_SPRINTF(trace_buf , BT_TMP_BUF_SIZE,
971 ("halbtc8723b1ant_set_ant_path(): we don't need to wait for H2C command completion because of Fw download fail!!!\n"));
972 BTC_TRACE(trace_buf);
973 break;
974 }
975
976 if (btcoexist->btc_read_1byte(btcoexist,
977 0x765) == 0x18)
978 break;
979
980 cnt_bt_cal_chk++;
981 if (cnt_bt_cal_chk > 20)
982 break;
983 }
984 } else {
985 /* set grant_bt to high */
986 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
987 }
988 /* set wlan_act to always low */
989 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
990
991 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
992 &is_in_mp_mode);
993 if (!is_in_mp_mode)
994 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
995 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
996 else
997 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
998 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
999
1000 /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL BT Vendor 0xac=0xf002 */
1001 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1002 u32tmp &= ~BIT(23);
1003 u32tmp &= ~BIT(24);
1004 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1005 } else {
1006 /* Use H2C to set GNT_BT to LOW */
1007 if (fw_ver >= 0x180000) {
1008 if (btcoexist->btc_read_1byte(btcoexist, 0x765) != 0) {
1009 h2c_parameter[0] = 0;
1010 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1011 h2c_parameter);
1012
1013 cnt_bt_cal_chk = 0;
1014 while (1) {
1015 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_FW_READY, &is_fw_ready);
1016 if (is_fw_ready == false) {
1017 BTC_SPRINTF(trace_buf ,
1018 BT_TMP_BUF_SIZE,
1019 ("halbtc8723b1ant_set_ant_path(): we don't need to wait for H2C command completion because of Fw download fail!!!\n"));
1020 BTC_TRACE(trace_buf);
1021 break;
1022 }
1023
1024 if (btcoexist->btc_read_1byte(btcoexist,
1025 0x765) == 0x0)
1026 break;
1027
1028 cnt_bt_cal_chk++;
1029 if (cnt_bt_cal_chk > 20)
1030 break;
1031 }
1032 }
1033 } else {
1034 /* BT calibration check */
1035 while (cnt_bt_cal_chk <= 20) {
1036 u8tmp = btcoexist->btc_read_1byte(btcoexist,
1037 0x49d);
1038 cnt_bt_cal_chk++;
1039 if (u8tmp & BIT(0)) {
1040 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1041 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
1042 cnt_bt_cal_chk);
1043 BTC_TRACE(trace_buf);
1044 delay_ms(50);
1045 } else {
1046 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1047 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
1048 cnt_bt_cal_chk);
1049 BTC_TRACE(trace_buf);
1050 break;
1051 }
1052 }
1053
1054 /* set grant_bt to PTA */
1055 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
1056 }
1057
1058 if (btcoexist->btc_read_1byte(btcoexist, 0x76e) != 0xc) {
1059 /* set wlan_act control by PTA */
1060 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
1061 }
1062
1063 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20,
1064 0x1); /* BT select s0/s1 is controlled by WiFi */
1065 }
1066
1067 if (use_ext_switch) {
1068 if (init_hwcfg) {
1069 /* 0x4c[23]=0, 0x4c[24]=1 Antenna control by WL/BT */
1070 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1071 u32tmp &= ~BIT(23);
1072 u32tmp |= BIT(24);
1073 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1074
1075
1076 u32tmp_1[0] = btcoexist->btc_read_4byte(btcoexist,
1077 0x948);
1078 if ((u32tmp_1[0] == 0x40) || (u32tmp_1[0] == 0x240))
1079 btcoexist->btc_write_4byte(btcoexist, 0x948,
1080 u32tmp_1[0]);
1081 else
1082 btcoexist->btc_write_4byte(btcoexist, 0x948,
1083 0x0);
1084
1085
1086 if (board_info->btdm_ant_pos ==
1087 BTC_ANTENNA_AT_MAIN_PORT) {
1088 /* tell firmware "no antenna inverse" */
1089 h2c_parameter[0] = 0;
1090 h2c_parameter[1] = 1; /* ext switch type */
1091 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1092 h2c_parameter);
1093 } else {
1094 /* tell firmware "antenna inverse" */
1095 h2c_parameter[0] = 1;
1096 h2c_parameter[1] = 1; /* ext switch type */
1097 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1098 h2c_parameter);
1099 }
1100 }
1101
1102 if (force_exec ||
1103 (coex_dm->cur_ant_pos_type !=
1104 coex_dm->pre_ant_pos_type)) {
1105 /* ext switch setting */
1106 switch (ant_pos_type) {
1107 case BTC_ANT_PATH_WIFI:
1108 if (board_info->btdm_ant_pos ==
1109 BTC_ANTENNA_AT_MAIN_PORT)
1110 btcoexist->btc_write_1byte_bitmask(
1111 btcoexist, 0x92c, 0x3,
1112 0x1);
1113 else
1114 btcoexist->btc_write_1byte_bitmask(
1115 btcoexist, 0x92c, 0x3,
1116 0x2);
1117 break;
1118 case BTC_ANT_PATH_BT:
1119 if (board_info->btdm_ant_pos ==
1120 BTC_ANTENNA_AT_MAIN_PORT)
1121 btcoexist->btc_write_1byte_bitmask(
1122 btcoexist, 0x92c, 0x3,
1123 0x2);
1124 else
1125 btcoexist->btc_write_1byte_bitmask(
1126 btcoexist, 0x92c, 0x3,
1127 0x1);
1128 break;
1129 default:
1130 case BTC_ANT_PATH_PTA:
1131 if (board_info->btdm_ant_pos ==
1132 BTC_ANTENNA_AT_MAIN_PORT)
1133 btcoexist->btc_write_1byte_bitmask(
1134 btcoexist, 0x92c, 0x3,
1135 0x1);
1136 else
1137 btcoexist->btc_write_1byte_bitmask(
1138 btcoexist, 0x92c, 0x3,
1139 0x2);
1140 break;
1141 }
1142 }
1143 } else {
1144 if (init_hwcfg) {
1145 /* 0x4c[23]=1, 0x4c[24]=0 Antenna control by 0x64 */
1146 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1147 u32tmp |= BIT(23);
1148 u32tmp &= ~BIT(24);
1149 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1150
1151 /* Fix Ext switch Main->S1, Aux->S0 */
1152 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
1153 0x0);
1154
1155 if (board_info->btdm_ant_pos ==
1156 BTC_ANTENNA_AT_MAIN_PORT) {
1157
1158 /* tell firmware "no antenna inverse" */
1159 h2c_parameter[0] = 0;
1160 h2c_parameter[1] =
1161 0; /* internal switch type */
1162 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1163 h2c_parameter);
1164 } else {
1165
1166 /* tell firmware "antenna inverse" */
1167 h2c_parameter[0] = 1;
1168 h2c_parameter[1] =
1169 0; /* internal switch type */
1170 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1171 h2c_parameter);
1172 }
1173 }
1174
1175 if (force_exec ||
1176 (coex_dm->cur_ant_pos_type !=
1177 coex_dm->pre_ant_pos_type)) {
1178 /* internal switch setting */
1179 switch (ant_pos_type) {
1180 case BTC_ANT_PATH_WIFI:
1181 if (board_info->btdm_ant_pos ==
1182 BTC_ANTENNA_AT_MAIN_PORT) {
1183 u32tmp_1[0] = btcoexist->btc_read_4byte(
1184 btcoexist, 0x948);
1185 if ((u32tmp_1[0] == 0x40) ||
1186 (u32tmp_1[0] == 0x240))
1187 btcoexist->btc_write_4byte(
1188 btcoexist, 0x948,
1189 u32tmp_1[0]);
1190 else
1191 btcoexist->btc_write_4byte(
1192 btcoexist, 0x948, 0x0);
1193 } else {
1194 u32tmp_1[0] = btcoexist->btc_read_4byte(
1195 btcoexist, 0x948);
1196 if ((u32tmp_1[0] == 0x40) ||
1197 (u32tmp_1[0] == 0x240))
1198 btcoexist->btc_write_4byte(
1199 btcoexist, 0x948,
1200 u32tmp_1[0]);
1201 else
1202 btcoexist->btc_write_4byte(
1203 btcoexist, 0x948,
1204 0x280);
1205 }
1206 break;
1207 case BTC_ANT_PATH_BT:
1208 if (board_info->btdm_ant_pos ==
1209 BTC_ANTENNA_AT_MAIN_PORT) {
1210 u32tmp_1[0] = btcoexist->btc_read_4byte(
1211 btcoexist, 0x948);
1212 if ((u32tmp_1[0] == 0x40) ||
1213 (u32tmp_1[0] == 0x240))
1214 btcoexist->btc_write_4byte(
1215 btcoexist, 0x948,
1216 u32tmp_1[0]);
1217 else
1218 btcoexist->btc_write_4byte(
1219 btcoexist, 0x948,
1220 0x280);
1221 } else {
1222 u32tmp_1[0] = btcoexist->btc_read_4byte(
1223 btcoexist, 0x948);
1224 if ((u32tmp_1[0] == 0x40) ||
1225 (u32tmp_1[0] == 0x240))
1226 btcoexist->btc_write_4byte(
1227 btcoexist, 0x948,
1228 u32tmp_1[0]);
1229 else
1230 btcoexist->btc_write_4byte(
1231 btcoexist, 0x948, 0x0);
1232 }
1233 break;
1234 default:
1235 case BTC_ANT_PATH_PTA:
1236 if (board_info->btdm_ant_pos ==
1237 BTC_ANTENNA_AT_MAIN_PORT)
1238 btcoexist->btc_write_4byte(
1239 btcoexist, 0x948,
1240 0x200);
1241 else
1242 btcoexist->btc_write_4byte(
1243 btcoexist, 0x948, 0x80);
1244 break;
1245 }
1246 }
1247 }
1248
1249 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1250
1251 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
1252 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1253 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
1254
1255 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1256 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x (after set ant path)\n",
1257 u32tmp, u8tmpa, u8tmpb);
1258 BTC_TRACE(trace_buf);
1259
1260 }
1261
1262 static
halbtc8723b1ant_ps_tdma_check_for_power_save_state(IN struct btc_coexist * btcoexist,IN boolean new_ps_state)1263 void halbtc8723b1ant_ps_tdma_check_for_power_save_state(
1264 IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1265 {
1266 u8 lps_mode = 0x0;
1267 u8 h2c_parameter[5] = {0x8, 0, 0, 0, 0};
1268
1269 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1270
1271 if (lps_mode) { /* already under LPS state */
1272 if (new_ps_state) {
1273 /* keep state under LPS, do nothing. */
1274 } else {
1275 /* will leave LPS state, turn off psTdma first */
1276 /* halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1277 8); */
1278 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1279 h2c_parameter);
1280 }
1281 } else { /* NO PS state */
1282 if (new_ps_state) {
1283 /* will enter LPS state, turn off psTdma first */
1284 /* halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1285 8); */
1286 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1287 h2c_parameter);
1288 } else {
1289 /* keep state under NO PS state, do nothing. */
1290 }
1291 }
1292 }
1293
1294 static
halbtc8723b1ant_power_save_state(IN struct btc_coexist * btcoexist,IN u8 ps_type,IN u8 lps_val,IN u8 rpwm_val)1295 void halbtc8723b1ant_power_save_state(IN struct btc_coexist *btcoexist,
1296 IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1297 {
1298 boolean low_pwr_disable = false;
1299
1300 switch (ps_type) {
1301 case BTC_PS_WIFI_NATIVE:
1302 /* recover to original 32k low power setting */
1303 low_pwr_disable = false;
1304 btcoexist->btc_set(btcoexist,
1305 BTC_SET_ACT_DISABLE_LOW_POWER,
1306 &low_pwr_disable);
1307 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1308 NULL);
1309 coex_sta->force_lps_on = false;
1310 break;
1311 case BTC_PS_LPS_ON:
1312 halbtc8723b1ant_ps_tdma_check_for_power_save_state(
1313 btcoexist, true);
1314 halbtc8723b1ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1315 lps_val, rpwm_val);
1316 /* when coex force to enter LPS, do not enter 32k low power. */
1317 low_pwr_disable = true;
1318 btcoexist->btc_set(btcoexist,
1319 BTC_SET_ACT_DISABLE_LOW_POWER,
1320 &low_pwr_disable);
1321 /* power save must executed before psTdma. */
1322 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1323 NULL);
1324 coex_sta->force_lps_on = true;
1325 break;
1326 case BTC_PS_LPS_OFF:
1327 halbtc8723b1ant_ps_tdma_check_for_power_save_state(
1328 btcoexist, false);
1329 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1330 NULL);
1331 coex_sta->force_lps_on = false;
1332 break;
1333 default:
1334 break;
1335 }
1336 }
1337
1338 static
halbtc8723b1ant_set_fw_pstdma(IN struct btc_coexist * btcoexist,IN u8 byte1,IN u8 byte2,IN u8 byte3,IN u8 byte4,IN u8 byte5)1339 void halbtc8723b1ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1340 IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1341 {
1342 u8 h2c_parameter[5] = {0};
1343 u8 real_byte1 = byte1, real_byte5 = byte5;
1344 boolean ap_enable = false;
1345
1346 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1347 &ap_enable);
1348
1349 if (ap_enable) {
1350 if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1351 real_byte1 &= ~BIT(4);
1352 real_byte1 |= BIT(5);
1353
1354 real_byte5 |= BIT(5);
1355 real_byte5 &= ~BIT(6);
1356
1357 halbtc8723b1ant_power_save_state(btcoexist,
1358 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1359 }
1360 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1361 halbtc8723b1ant_power_save_state(btcoexist,
1362 BTC_PS_LPS_ON, 0x50, 0x4);
1363
1364 } else {
1365 halbtc8723b1ant_power_save_state(btcoexist,
1366 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1367 }
1368
1369 h2c_parameter[0] = real_byte1;
1370 h2c_parameter[1] = byte2;
1371 h2c_parameter[2] = byte3;
1372 h2c_parameter[3] = byte4;
1373 h2c_parameter[4] = real_byte5;
1374
1375 coex_dm->ps_tdma_para[0] = real_byte1;
1376 coex_dm->ps_tdma_para[1] = byte2;
1377 coex_dm->ps_tdma_para[2] = byte3;
1378 coex_dm->ps_tdma_para[3] = byte4;
1379 coex_dm->ps_tdma_para[4] = real_byte5;
1380
1381 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1382 }
1383
1384 static
halbtc8723b1ant_ps_tdma(IN struct btc_coexist * btcoexist,IN boolean force_exec,IN boolean turn_on,IN u8 type)1385 void halbtc8723b1ant_ps_tdma(IN struct btc_coexist *btcoexist,
1386 IN boolean force_exec, IN boolean turn_on, IN u8 type)
1387 {
1388 struct btc_board_info *board_info = &btcoexist->board_info;
1389 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1390 boolean wifi_busy = false;
1391 u8 rssi_adjust_val = 0;
1392 u8 ps_tdma_byte4_val = 0x50, ps_tdma_byte0_val = 0x51,
1393 ps_tdma_byte3_val = 0x10;
1394 s8 wifi_duration_adjust = 0x0;
1395 static boolean pre_wifi_busy = false;
1396
1397 #ifdef PLATFORM_WINDOWS
1398 u32 wait_counter = 0;
1399 #endif
1400
1401 #ifdef PLATFORM_WINDOWS
1402 while (PlatformAtomicExchange((pu4Byte)&coex_dm->setting_tdma, TRUE) == TRUE) {
1403 /*wait setting*/
1404 wait_counter++;
1405 PlatformStallExecution(50); /*100 us*/
1406 if (wait_counter > 3000) {
1407 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1408 "[BTCoex], Wait fail for setting TDMA\n");
1409 BTC_TRACE(trace_buf);
1410 return;
1411 }
1412 }
1413 if (wait_counter != 0) {
1414 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1415 "[BTCoex], Wait setting for TDMA(%d)\n", wait_counter);
1416 BTC_TRACE(trace_buf);
1417 }
1418 #endif
1419
1420
1421 #if BT_8723B_1ANT_ANTDET_ENABLE
1422 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
1423 if (board_info->btdm_ant_num_by_ant_det == 2) {
1424 if (turn_on)
1425 type = type +
1426 100; /* for WiFi RSSI low or BT RSSI low */
1427 else
1428 type = 1; /* always translate to TDMA(off,1) for TDMA-off case */
1429 }
1430
1431 #endif
1432 #endif
1433
1434 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1435
1436 if (wifi_busy != pre_wifi_busy) {
1437 force_exec = true;
1438 pre_wifi_busy = wifi_busy;
1439 }
1440
1441 if (!force_exec) {
1442 if ((turn_on == coex_dm->cur_ps_tdma_on) &&
1443 (type == coex_dm->cur_ps_tdma)) {
1444 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1445 "[BTCoex], Skip TDMA because no change TDMA(%s, %d)\n",
1446 (coex_dm->cur_ps_tdma_on ? "on" : "off"), coex_dm->cur_ps_tdma);
1447 BTC_TRACE(trace_buf);
1448
1449 #ifdef PLATFORM_WINDOWS
1450 PlatformAtomicExchange((pu4Byte)&coex_dm->setting_tdma, FALSE);
1451 #endif
1452 return;
1453 }
1454 }
1455
1456
1457 if (coex_sta->scan_ap_num <= 5) {
1458 wifi_duration_adjust = 5;
1459
1460 if (coex_sta->a2dp_bit_pool >= 35)
1461 wifi_duration_adjust = -10;
1462 else if (coex_sta->a2dp_bit_pool >= 45)
1463 wifi_duration_adjust = -15;
1464 } else if (coex_sta->scan_ap_num >= 40) {
1465 wifi_duration_adjust = -15;
1466
1467 if (coex_sta->a2dp_bit_pool < 35)
1468 wifi_duration_adjust = -5;
1469 else if (coex_sta->a2dp_bit_pool < 45)
1470 wifi_duration_adjust = -10;
1471 } else if (coex_sta->scan_ap_num >= 20) {
1472 wifi_duration_adjust = -10;
1473
1474 if (coex_sta->a2dp_bit_pool >= 45)
1475 wifi_duration_adjust = -15;
1476 } else {
1477 wifi_duration_adjust = 0;
1478
1479 if (coex_sta->a2dp_bit_pool >= 35)
1480 wifi_duration_adjust = -10;
1481 else if (coex_sta->a2dp_bit_pool >= 45)
1482 wifi_duration_adjust = -15;
1483 }
1484
1485 if ((type == 1) || (type == 2) || (type == 9) || (type == 11) ||
1486 (type == 101)
1487 || (type == 102) || (type == 109) || (type == 101)) {
1488 #if 0
1489 if (!coex_sta->force_lps_on) { /* Native power save TDMA, only for A2DP-only case 1/2/9/11 while wifi noisy threshold > 30 */
1490 ps_tdma_byte0_val = 0x61; /* no null-pkt */
1491 ps_tdma_byte3_val = 0x11; /* no tx-pause at BT-slot */
1492 ps_tdma_byte4_val =
1493 0x10; /* 0x778 = d/1 toggle, no dynamic slot */
1494 } else {
1495 #endif
1496 ps_tdma_byte0_val = 0x51; /* null-pkt */
1497 ps_tdma_byte3_val = 0x10; /* tx-pause at BT-slot */
1498 ps_tdma_byte4_val =
1499 0x50; /* 0x778 = d/1 toggle, dynamic slot */
1500 /* } */
1501 } else if ((type == 3) || (type == 13) || (type == 14) ||
1502 (type == 103) || (type == 113) || (type == 114)) {
1503 ps_tdma_byte0_val = 0x51; /* null-pkt */
1504 ps_tdma_byte3_val = 0x10; /* tx-pause at BT-slot */
1505 ps_tdma_byte4_val =
1506 0x10; /* 0x778 = d/1 toggle, no dynamic slot */
1507 #if 0
1508 if (!wifi_busy)
1509 ps_tdma_byte4_val = ps_tdma_byte4_val |
1510 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1511 #endif
1512 } else { /* native power save case */
1513 ps_tdma_byte0_val = 0x61; /* no null-pkt */
1514 ps_tdma_byte3_val = 0x11; /* no tx-pause at BT-slot */
1515 ps_tdma_byte4_val =
1516 0x11; /* 0x778 = d/1 toggle, no dynamic slot */
1517 /* psTdmaByte4Va is not defne for 0x778 = d/1, 1/1 case */
1518 }
1519
1520 /* if (bt_link_info->slave_role == true) */
1521 if ((bt_link_info->slave_role == true) && (bt_link_info->a2dp_exist))
1522 ps_tdma_byte4_val = ps_tdma_byte4_val |
1523 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1524
1525 if (type > 100) {
1526 ps_tdma_byte0_val = ps_tdma_byte0_val |
1527 0x82; /* set antenna control by SW */
1528 ps_tdma_byte3_val = ps_tdma_byte3_val |
1529 0x60; /* set antenna no toggle, control by antenna diversity */
1530 }
1531
1532
1533 if (turn_on) {
1534 switch (type) {
1535 default:
1536 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
1537 0x1a, 0x1a, 0x0, ps_tdma_byte4_val);
1538 break;
1539 case 1:
1540 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1541 ps_tdma_byte0_val, 0x3a +
1542 wifi_duration_adjust, 0x03,
1543 ps_tdma_byte3_val, ps_tdma_byte4_val);
1544 break;
1545 case 2:
1546 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1547 ps_tdma_byte0_val, 0x2d +
1548 wifi_duration_adjust, 0x03,
1549 ps_tdma_byte3_val, ps_tdma_byte4_val);
1550 break;
1551 case 3:
1552 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1553 ps_tdma_byte0_val, 0x30, 0x03,
1554 ps_tdma_byte3_val, ps_tdma_byte4_val);
1555 break;
1556 case 4:
1557 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
1558 0x15, 0x3, 0x14, 0x0);
1559 break;
1560 case 5:
1561 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1562 ps_tdma_byte0_val, 0x1f, 0x3,
1563 ps_tdma_byte3_val, 0x11);
1564 break;
1565 case 6:
1566 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1567 ps_tdma_byte0_val, 0x20, 0x3,
1568 ps_tdma_byte3_val, 0x11);
1569 break;
1570 case 7:
1571 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
1572 0xc, 0x5, 0x0, 0x0);
1573 break;
1574 case 8:
1575 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
1576 0x25, 0x3, 0x10, 0x0);
1577 break;
1578 case 9:
1579 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1580 ps_tdma_byte0_val, 0x21, 0x3,
1581 ps_tdma_byte3_val, ps_tdma_byte4_val);
1582 break;
1583 case 10:
1584 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
1585 0xa, 0xa, 0x0, 0x40);
1586 break;
1587 case 11:
1588 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1589 ps_tdma_byte0_val, 0x21, 0x03,
1590 ps_tdma_byte3_val, ps_tdma_byte4_val);
1591 break;
1592 case 12:
1593 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
1594 0x0a, 0x0a, 0x0, 0x50);
1595 break;
1596 case 13:
1597 if (coex_sta->scan_ap_num <= 3)
1598 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1599 ps_tdma_byte0_val, 0x40, 0x3,
1600 ps_tdma_byte3_val,
1601 ps_tdma_byte4_val);
1602 else
1603 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1604 ps_tdma_byte0_val, 0x21, 0x3,
1605 ps_tdma_byte3_val,
1606 ps_tdma_byte4_val);
1607 break;
1608 case 14:
1609 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1610 0x51, 0x10, 0x3, 0x10, 0x54);
1611 #if 0
1612 if (coex_sta->scan_ap_num <= 3)
1613 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1614 0x51, 0x30, 0x3, 0x10, 0x50);
1615 else
1616 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1617 ps_tdma_byte0_val, 0x21, 0x3,
1618 ps_tdma_byte3_val,
1619 ps_tdma_byte4_val);
1620 #endif
1621 break;
1622 case 15:
1623 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x13,
1624 0xa, 0x3, 0x8, 0x0);
1625 break;
1626 case 16:
1627 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
1628 0x15, 0x3, 0x10, 0x0);
1629 break;
1630 case 17:
1631 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1632 0x55, 0x10, 0x3, 0x10, 0x54);
1633 break;
1634 case 18:
1635 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x93,
1636 0x25, 0x3, 0x10, 0x0);
1637 break;
1638 case 20:
1639 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1640 ps_tdma_byte0_val, 0x3f, 0x03,
1641 ps_tdma_byte3_val, 0x10);
1642 break;
1643 case 21:
1644 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x61,
1645 0x25, 0x03, 0x11, 0x11);
1646 break;
1647 case 22:
1648 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1649 ps_tdma_byte0_val, 0x25, 0x03,
1650 ps_tdma_byte3_val, 0x10);
1651 break;
1652 case 23:
1653 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
1654 0x25, 0x3, 0x31, 0x18);
1655 break;
1656 case 24:
1657 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
1658 0x15, 0x3, 0x31, 0x18);
1659 break;
1660 case 25:
1661 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
1662 0xa, 0x3, 0x31, 0x18);
1663 break;
1664 case 26:
1665 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
1666 0xa, 0x3, 0x31, 0x18);
1667 break;
1668 case 27:
1669 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xe3,
1670 0x25, 0x3, 0x31, 0x98);
1671 break;
1672 case 28:
1673 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x69,
1674 0x25, 0x3, 0x31, 0x0);
1675 break;
1676 case 29:
1677 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xab,
1678 0x1a, 0x1a, 0x1, 0x10);
1679 break;
1680 case 30:
1681 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
1682 0x30, 0x3, 0x10, 0x10);
1683 break;
1684 case 31:
1685 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xd3,
1686 0x1a, 0x1a, 0, 0x58);
1687 break;
1688 case 32:
1689 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1690 ps_tdma_byte0_val, 0x35, 0x3,
1691 ps_tdma_byte3_val, ps_tdma_byte4_val);
1692 break;
1693 case 33:
1694 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1695 ps_tdma_byte0_val, 0x35, 0x3,
1696 ps_tdma_byte3_val, 0x10);
1697 break;
1698 case 34:
1699 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x53,
1700 0x1a, 0x1a, 0x0, 0x10);
1701 break;
1702 case 35:
1703 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x63,
1704 0x1a, 0x1a, 0x0, 0x10);
1705 break;
1706 case 36:
1707 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0xd3,
1708 0x12, 0x3, 0x14, 0x50);
1709 break;
1710 case 37:
1711 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51,
1712 0x10, 0x3, 0x10, 0x54);
1713 break;
1714 case 38:
1715 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x61,
1716 0x10, 0x3, 0x11, 0x54);
1717 break;
1718 case 40: /* SoftAP only with no sta associated,BT disable ,TDMA mode for power saving */
1719 /* here softap mode screen off will cost 70-80mA for phone */
1720 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x23,
1721 0x18, 0x00, 0x10, 0x24);
1722 break;
1723 case 41:
1724 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1725 0x51, 0x10, 0x7, 0x10, 0x54);
1726 break;
1727 case 42:
1728 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1729 0x55, 0x10, 0x7, 0x10, 0x54);
1730 break;
1731 case 43:
1732 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1733 0x51, 0x15, 0x3, 0x10, 0x50);
1734 break;
1735 case 44:
1736 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1737 0x51, 0x10, 0x3, 0x10, 0x55);
1738 break;
1739 /* for 1-Ant translate to 2-Ant */
1740 case 101:
1741 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1742 ps_tdma_byte0_val, 0x3a +
1743 wifi_duration_adjust, 0x03,
1744 ps_tdma_byte3_val, ps_tdma_byte4_val);
1745 break;
1746 case 102:
1747 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1748 ps_tdma_byte0_val, 0x2d +
1749 wifi_duration_adjust, 0x03,
1750 ps_tdma_byte3_val, ps_tdma_byte4_val);
1751 break;
1752 case 103:
1753 /* halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51, 0x1d, 0x1d, 0x0, ps_tdma_byte4_val); */
1754 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1755 ps_tdma_byte0_val, 0x3a, 0x03,
1756 ps_tdma_byte3_val, ps_tdma_byte4_val);
1757 break;
1758 case 105:
1759 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1760 ps_tdma_byte0_val, 0x15, 0x3,
1761 ps_tdma_byte3_val, 0x11);
1762 break;
1763 case 106:
1764 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1765 ps_tdma_byte0_val, 0x20, 0x3,
1766 ps_tdma_byte3_val, 0x11);
1767 break;
1768 case 109:
1769 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1770 ps_tdma_byte0_val, 0x21, 0x3,
1771 ps_tdma_byte3_val, ps_tdma_byte4_val);
1772 break;
1773 case 111:
1774 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1775 ps_tdma_byte0_val, 0x21, 0x03,
1776 ps_tdma_byte3_val, ps_tdma_byte4_val);
1777 break;
1778 case 113:
1779 /* halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x51, 0x12, 0x12, 0x0, ps_tdma_byte4_val); */
1780 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1781 ps_tdma_byte0_val, 0x21, 0x3,
1782 ps_tdma_byte3_val, ps_tdma_byte4_val);
1783 break;
1784 case 114:
1785 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1786 ps_tdma_byte0_val, 0x21, 0x3,
1787 ps_tdma_byte3_val, ps_tdma_byte4_val);
1788 break;
1789 case 120:
1790 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1791 ps_tdma_byte0_val, 0x3f, 0x03,
1792 ps_tdma_byte3_val, 0x10);
1793 break;
1794 case 122:
1795 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1796 ps_tdma_byte0_val, 0x25, 0x03,
1797 ps_tdma_byte3_val, 0x10);
1798 break;
1799 case 132:
1800 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1801 ps_tdma_byte0_val, 0x25, 0x03,
1802 ps_tdma_byte3_val, ps_tdma_byte4_val);
1803 break;
1804 case 133:
1805 halbtc8723b1ant_set_fw_pstdma(btcoexist,
1806 ps_tdma_byte0_val, 0x25, 0x03,
1807 ps_tdma_byte3_val, 0x11);
1808 break;
1809
1810 }
1811 } else {
1812
1813 /* disable PS tdma */
1814 switch (type) {
1815 case 8: /* PTA Control */
1816 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x8,
1817 0x0, 0x0, 0x0, 0x0);
1818 break;
1819 case 0:
1820 default: /* Software control, Antenna at BT side */
1821 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x0,
1822 0x0, 0x0, 0x0, 0x0);
1823 break;
1824 case 1: /* 2-Ant, 0x778=3, antenna control by antenna diversity */
1825 halbtc8723b1ant_set_fw_pstdma(btcoexist, 0x0,
1826 0x0, 0x0, 0x48, 0x0);
1827 break;
1828 }
1829 }
1830 rssi_adjust_val = 0;
1831 btcoexist->btc_set(btcoexist,
1832 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
1833
1834 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1835 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
1836 btcoexist->btc_read_4byte(btcoexist, 0x948),
1837 btcoexist->btc_read_1byte(btcoexist, 0x765),
1838 btcoexist->btc_read_1byte(btcoexist, 0x67));
1839 BTC_TRACE(trace_buf);
1840
1841 /* update pre state */
1842 coex_dm->cur_ps_tdma_on = turn_on;
1843 coex_dm->cur_ps_tdma = type;
1844
1845 #ifdef PLATFORM_WINDOWS
1846 PlatformAtomicExchange((pu4Byte)&coex_dm->setting_tdma, FALSE);
1847 #endif
1848
1849
1850 }
1851
1852 static
1853 void halbtc8723b1ant_tdma_duration_adjust_for_acl(IN struct btc_coexist
1854 *btcoexist, IN u8 wifi_status)
1855 {
1856 static s32 up, dn, m, n, wait_count;
1857 s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
1858 u8 retry_count = 0, bt_info_ext;
1859 boolean wifi_busy = false;
1860
1861 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY == wifi_status)
1862 wifi_busy = true;
1863 else
1864 wifi_busy = false;
1865
1866 if ((BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN ==
1867 wifi_status) ||
1868 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN == wifi_status) ||
1869 (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIFIC_PKT ==
1870 wifi_status)) {
1871 if (coex_dm->cur_ps_tdma != 1 &&
1872 coex_dm->cur_ps_tdma != 2 &&
1873 coex_dm->cur_ps_tdma != 3 &&
1874 coex_dm->cur_ps_tdma != 9) {
1875 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
1876 9);
1877 coex_dm->ps_tdma_du_adj_type = 9;
1878
1879 up = 0;
1880 dn = 0;
1881 m = 1;
1882 n = 3;
1883 result = 0;
1884 wait_count = 0;
1885 }
1886 return;
1887 }
1888
1889 if (!coex_dm->auto_tdma_adjust) {
1890 coex_dm->auto_tdma_adjust = true;
1891
1892 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1893 coex_dm->ps_tdma_du_adj_type = 2;
1894 /* ============ */
1895 up = 0;
1896 dn = 0;
1897 m = 1;
1898 n = 3;
1899 result = 0;
1900 wait_count = 0;
1901 } else {
1902 /* acquire the BT TRx retry count from BT_Info byte2 */
1903 retry_count = coex_sta->bt_retry_cnt;
1904 bt_info_ext = coex_sta->bt_info_ext;
1905
1906 if ((coex_sta->low_priority_tx) > 1050 ||
1907 (coex_sta->low_priority_rx) > 1250)
1908 retry_count++;
1909
1910 result = 0;
1911 wait_count++;
1912
1913 if (retry_count ==
1914 0) { /* no retry in the last 2-second duration */
1915 up++;
1916 dn--;
1917
1918 if (dn <= 0)
1919 dn = 0;
1920
1921 if (up >= n) { /* if retry count during continuous n*2 seconds is 0, enlarge WiFi duration */
1922 wait_count = 0;
1923 n = 3;
1924 up = 0;
1925 dn = 0;
1926 result = 1;
1927 }
1928 } else if (retry_count <=
1929 3) { /* <=3 retry in the last 2-second duration */
1930 up--;
1931 dn++;
1932
1933 if (up <= 0)
1934 up = 0;
1935
1936 if (dn == 2) { /* if continuous 2 retry count(every 2 seconds) >0 and < 3, reduce WiFi duration */
1937 if (wait_count <= 2)
1938 m++; /* to avoid loop between the two levels */
1939 else
1940 m = 1;
1941
1942 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
1943 m = 20;
1944
1945 n = 3 * m;
1946 up = 0;
1947 dn = 0;
1948 wait_count = 0;
1949 result = -1;
1950 }
1951 } else { /* retry count > 3, once retry count > 3, to reduce WiFi duration */
1952 if (wait_count == 1)
1953 m++; /* to avoid loop between the two levels */
1954 else
1955 m = 1;
1956
1957 if (m >= 20) /* maximum of m = 20 ' will recheck if need to adjust wifi duration in maximum time interval 120 seconds */
1958 m = 20;
1959
1960 n = 3 * m;
1961 up = 0;
1962 dn = 0;
1963 wait_count = 0;
1964 result = -1;
1965 }
1966
1967 if (result == -1) {
1968 /* if( (BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext)) &&
1969 ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) )
1970 {
1971 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1972 coex_dm->ps_tdma_du_adj_type = 9;
1973 }
1974 else */ if (coex_dm->cur_ps_tdma == 1) {
1975 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1976 true, 2);
1977 coex_dm->ps_tdma_du_adj_type = 2;
1978 } else if (coex_dm->cur_ps_tdma == 2) {
1979 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1980 true, 9);
1981 coex_dm->ps_tdma_du_adj_type = 9;
1982 } else if (coex_dm->cur_ps_tdma == 9) {
1983 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1984 true, 11);
1985 coex_dm->ps_tdma_du_adj_type = 11;
1986 }
1987 } else if (result == 1) {
1988 /* if( (BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(bt_info_ext)) &&
1989 ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) )
1990 {
1991 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1992 coex_dm->ps_tdma_du_adj_type = 9;
1993 }
1994 else */ if (coex_dm->cur_ps_tdma == 11) {
1995 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1996 true, 9);
1997 coex_dm->ps_tdma_du_adj_type = 9;
1998 } else if (coex_dm->cur_ps_tdma == 9) {
1999 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2000 true, 2);
2001 coex_dm->ps_tdma_du_adj_type = 2;
2002 } else if (coex_dm->cur_ps_tdma == 2) {
2003 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC,
2004 true, 1);
2005 coex_dm->ps_tdma_du_adj_type = 1;
2006 }
2007 } else { /* no change */
2008 /* Bryant Modify
2009 if(wifi_busy != pre_wifi_busy)
2010 {
2011 pre_wifi_busy = wifi_busy;
2012 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, true, coex_dm->cur_ps_tdma);
2013 }
2014 */
2015
2016 }
2017
2018 if (coex_dm->cur_ps_tdma != 1 &&
2019 coex_dm->cur_ps_tdma != 2 &&
2020 coex_dm->cur_ps_tdma != 9 &&
2021 coex_dm->cur_ps_tdma != 11) {
2022 /* recover to previous adjust type */
2023 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2024 coex_dm->ps_tdma_du_adj_type);
2025 }
2026 }
2027 }
2028
2029
2030 /* *********************************************
2031 *
2032 * Non-Software Coex Mechanism start
2033 *
2034 * ********************************************* */
2035 static
2036 void halbtc8723b1ant_action_bt_whck_test(IN struct btc_coexist *btcoexist)
2037 {
2038 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2039 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
2040 false, false);
2041 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2042 }
2043
2044 static
2045 void halbtc8723b1ant_action_hs(IN struct btc_coexist *btcoexist)
2046 {
2047 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2048 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2049 }
2050
2051 static
2052 void halbtc8723b1ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
2053 {
2054 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2055 boolean wifi_connected = false, ap_enable = false, wifi_busy = false,
2056 bt_busy = false;
2057
2058 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2059 &ap_enable);
2060 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2061 &wifi_connected);
2062 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2063 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2064
2065 if (coex_sta->bt_abnormal_scan) {
2066 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2067 33);
2068 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2069 } else if ((!wifi_connected) && (!coex_sta->wifi_is_high_pri_task)) {
2070 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2071 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2072 NORMAL_EXEC, false, false);
2073 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2074 } else if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
2075 (bt_link_info->a2dp_exist)) {
2076 /* SCO/HID/A2DP busy */
2077
2078 if (coex_sta->c2h_bt_remote_name_req)
2079 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2080 33);
2081 else
2082 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2083 32);
2084
2085 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2086 } else if ((bt_link_info->pan_exist) || (wifi_busy)) {
2087
2088 if (coex_sta->c2h_bt_remote_name_req)
2089 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2090 33);
2091 else
2092 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2093 32);
2094
2095 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2096 } else {
2097
2098 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2099 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2100 NORMAL_EXEC, false, false);
2101 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2102
2103 }
2104 }
2105
2106 static
2107 void halbtc8723b1ant_action_bt_sco_hid_only_busy(IN struct btc_coexist
2108 *btcoexist, IN u8 wifi_status)
2109 {
2110 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2111 boolean wifi_connected = false;
2112
2113 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2114 &wifi_connected);
2115
2116 /* tdma and coex table */
2117
2118 if (bt_link_info->sco_exist) {
2119 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2120 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2121 } else { /* HID */
2122 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
2123 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2124 }
2125 }
2126
2127 static
2128 void halbtc8723b1ant_action_wifi_only(IN struct btc_coexist *btcoexist)
2129 {
2130 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2131 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2132 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, FORCE_EXEC,
2133 false, false);
2134 }
2135
2136 static
2137 void halbtc8723b1ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
2138 {
2139 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2140
2141 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
2142 false, false);
2143
2144 if ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2145 coex_dm->bt_status) ||
2146 (BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE ==
2147 coex_dm->bt_status))
2148 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 20);
2149 else if (!bt_link_info->pan_exist)
2150 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2151 else
2152 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 21);
2153
2154 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, FALSE, 8);
2155
2156 }
2157
2158 static
2159 void halbtc8723b1ant_action_wifi_connected_bt_acl_busy(IN struct btc_coexist
2160 *btcoexist, IN u8 wifi_status)
2161 {
2162 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2163 boolean wifi_busy = false;
2164 boolean hid_rcu = false;
2165 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2166 u32 wifi_bw = 1;
2167
2168 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2169 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2170 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2171
2172 if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips))
2173 bt_link_info->slave_role = true;
2174 else
2175 bt_link_info->slave_role = false;
2176
2177 if (bt_link_info->hid_only) { /* HID */
2178 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
2179 wifi_status);
2180 coex_dm->auto_tdma_adjust = false;
2181 return;
2182 } else if (bt_link_info->a2dp_only) { /* A2DP */
2183
2184 #if 0
2185 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE == wifi_status) {
2186 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2187 32);
2188 halbtc8723b1ant_coex_table_with_type(btcoexist,
2189 NORMAL_EXEC, 4);
2190 coex_dm->auto_tdma_adjust = false;
2191 } else {
2192 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2193 37);
2194 halbtc8723b1ant_coex_table_with_type(btcoexist,
2195 NORMAL_EXEC, 16);
2196 coex_dm->auto_tdma_adjust = false;
2197 }
2198 #endif
2199 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 19);
2200
2201 if (coex_sta->connect_ap_period_cnt > 0)
2202 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 44);
2203 else
2204 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 37);
2205
2206 coex_dm->auto_tdma_adjust = false;
2207
2208 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
2209 (bt_link_info->hid_exist && bt_link_info->a2dp_exist && bt_link_info->pan_exist)) {
2210
2211 /* A2DP+PAN(OPP,FTP), HID+A2DP+PAN(OPP,FTP) */
2212 #if 0
2213 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2214 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2215 #endif
2216 if (bt_link_info->hid_exist)
2217 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2218 else
2219 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 19);
2220
2221 if (wifi_busy)
2222 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 41);
2223 else
2224 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, TRUE, 43);
2225
2226 coex_dm->auto_tdma_adjust = false;
2227
2228 } else if (bt_link_info->hid_exist &&
2229 bt_link_info->a2dp_exist) { /* HID+A2DP */
2230
2231 #if 1
2232 if (coex_sta->a2dp_bit_pool < 40) { /*for longer wifi slot RS1 */
2233 if (wifi_bw == 0) { /*11bg mode*/
2234 #if 1
2235 if (iot_peer == BTC_IOT_PEER_ATHEROS) {
2236 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 23);
2237 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2238 } else {
2239 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2240 halbtc8723b1ant_set_wltoggle_coex_table(btcoexist, NORMAL_EXEC,
2241 0x1, 0xaa, 0x5a, 0x5a, 0x5a);
2242 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 42);
2243 }
2244 #endif
2245 #if 0
2246 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 16);
2247 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2248 #endif
2249
2250 } else { /*11n mode*/
2251 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2252 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2253 }
2254 } else { /*for shorter wifi slot RS2 */
2255
2256 if (wifi_bw == 0) { /* 11bg mode */
2257 if (iot_peer == BTC_IOT_PEER_ATHEROS)
2258 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 23);
2259 else
2260 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 16);
2261 } else { /*11n mode*/
2262 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2263 }
2264 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2265 }
2266 #endif
2267 } else if ((bt_link_info->pan_only) || (bt_link_info->hid_exist &&
2268 bt_link_info->pan_exist)) { /* PAN(OPP,FTP), HID+PAN(OPP,FTP) */
2269
2270 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2271
2272 if (BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE == wifi_status)
2273 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2274 else
2275 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
2276
2277 coex_dm->auto_tdma_adjust = false;
2278 } else {
2279 /* BT no-profile busy (0x9) */
2280 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2281 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33);
2282
2283 coex_dm->auto_tdma_adjust = false;
2284 }
2285 }
2286
2287 static
2288 void halbtc8723b1ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
2289 {
2290
2291 /* tdma and coex table */
2292 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2293 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC,
2294 false, false);
2295 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2296 }
2297
2298 static
2299 void halbtc8723b1ant_action_wifi_not_connected_scan(IN struct btc_coexist
2300 *btcoexist)
2301 {
2302 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2303
2304 /* tdma and coex table */
2305 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
2306 if (bt_link_info->a2dp_exist) {
2307 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2308 38);
2309 halbtc8723b1ant_coex_table_with_type(btcoexist,
2310 NORMAL_EXEC, 3);
2311 } else if (bt_link_info->a2dp_exist &&
2312 bt_link_info->pan_exist) {
2313 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2314 22);
2315 halbtc8723b1ant_coex_table_with_type(btcoexist,
2316 NORMAL_EXEC, 4);
2317 } else {
2318 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2319 20);
2320 halbtc8723b1ant_coex_table_with_type(btcoexist,
2321 NORMAL_EXEC, 4);
2322 }
2323 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2324 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
2325 coex_dm->bt_status)) {
2326 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
2327 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
2328 } else {
2329 /* Bryant Add */
2330 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2331 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2332 NORMAL_EXEC, false, false);
2333 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2334 }
2335 }
2336
2337 static
2338 void halbtc8723b1ant_action_wifi_not_connected_asso_auth(
2339 IN struct btc_coexist *btcoexist)
2340 {
2341 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2342
2343 /* tdma and coex table */
2344 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
2345 (bt_link_info->a2dp_exist)) {
2346 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2347 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
2348 } else if (bt_link_info->pan_exist) {
2349 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
2350 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4);
2351 } else {
2352 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2353 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2354 NORMAL_EXEC, false, false);
2355 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
2356 }
2357 }
2358
2359 static
2360 void halbtc8723b1ant_action_wifi_connected_scan(IN struct btc_coexist
2361 *btcoexist)
2362 {
2363 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2364
2365 /* tdma and coex table */
2366 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
2367 if (bt_link_info->a2dp_exist) {
2368 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2369 38);
2370 halbtc8723b1ant_coex_table_with_type(btcoexist,
2371 NORMAL_EXEC, 3);
2372 } else if (bt_link_info->a2dp_exist &&
2373 bt_link_info->pan_exist) {
2374 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2375 22);
2376 halbtc8723b1ant_coex_table_with_type(btcoexist,
2377 NORMAL_EXEC, 4);
2378 } else {
2379 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2380 20);
2381 halbtc8723b1ant_coex_table_with_type(btcoexist,
2382 NORMAL_EXEC, 4);
2383 }
2384 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2385 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
2386 coex_dm->bt_status)) {
2387 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
2388 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN);
2389 } else {
2390 /* Bryant Add */
2391 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2392 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2393 NORMAL_EXEC, false, false);
2394 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2395 }
2396 }
2397
2398 static
2399 void halbtc8723b1ant_action_wifi_connected_specific_packet(
2400 IN struct btc_coexist *btcoexist)
2401 {
2402 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2403 boolean wifi_busy = false;
2404
2405 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2406
2407 /* no specific packet process for both WiFi and BT very busy */
2408 if ((wifi_busy) && ((bt_link_info->pan_exist) ||
2409 (coex_sta->num_of_profile >= 2)))
2410 return;
2411
2412 /* tdma and coex table */
2413 if (bt_link_info->a2dp_exist) {
2414 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 38);
2415 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
2416 } else if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
2417 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
2418 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2419 } else if (bt_link_info->pan_exist) {
2420 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
2421 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2422 } else {
2423 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
2424 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2425 NORMAL_EXEC, false, false);
2426 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2427 }
2428 }
2429
2430 static
2431 void halbtc8723b1ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
2432 {
2433 boolean wifi_busy = false;
2434 boolean scan = false, link = false, roam = false;
2435 boolean under_4way = false, ap_enable = false;
2436
2437 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2438 "[BTCoex], CoexForWifiConnect()===>\n");
2439 BTC_TRACE(trace_buf);
2440
2441 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
2442 &under_4way);
2443 if (under_4way) {
2444 halbtc8723b1ant_action_wifi_connected_specific_packet(
2445 btcoexist);
2446 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2447 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
2448 BTC_TRACE(trace_buf);
2449 return;
2450 }
2451
2452 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2453 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2454 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2455 if (scan || link || roam) {
2456 if (scan)
2457 halbtc8723b1ant_action_wifi_connected_scan(btcoexist);
2458 else
2459 halbtc8723b1ant_action_wifi_connected_specific_packet(
2460 btcoexist);
2461 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2462 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
2463 BTC_TRACE(trace_buf);
2464 return;
2465 }
2466
2467 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
2468 &ap_enable);
2469 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2470
2471
2472 /* tdma and coex table */
2473 if (!wifi_busy) {
2474 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
2475 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2476 btcoexist,
2477 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2478 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY ==
2479 coex_dm->bt_status) ||
2480 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
2481 coex_dm->bt_status)) {
2482 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
2483 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
2484 } else {
2485 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
2486 8);
2487 halbtc8723b1ant_set_ant_path(btcoexist,
2488 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
2489 /* if ((coex_sta->high_priority_tx) +
2490 (coex_sta->high_priority_rx) <= 60) */
2491 halbtc8723b1ant_coex_table_with_type(btcoexist,
2492 NORMAL_EXEC, 2);
2493 /* else
2494 halbtc8723b1ant_coex_table_with_type(btcoexist,
2495 NORMAL_EXEC, 7); */
2496 }
2497 } else {
2498 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
2499 halbtc8723b1ant_action_wifi_connected_bt_acl_busy(
2500 btcoexist,
2501 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2502 } else if ((BT_8723B_1ANT_BT_STATUS_SCO_BUSY ==
2503 coex_dm->bt_status) ||
2504 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY ==
2505 coex_dm->bt_status)) {
2506 halbtc8723b1ant_action_bt_sco_hid_only_busy(btcoexist,
2507 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY);
2508 } else {
2509 /* halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
2510 8);
2511 halbtc8723b1ant_set_ant_path(btcoexist,
2512 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
2513 if ((coex_sta->high_priority_tx) +
2514 (coex_sta->high_priority_rx) <= 60)
2515 halbtc8723b1ant_coex_table_with_type(btcoexist,
2516 NORMAL_EXEC, 2);
2517 else
2518 halbtc8723b1ant_coex_table_with_type(btcoexist,
2519 NORMAL_EXEC, 7); */
2520 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2521 32);
2522 halbtc8723b1ant_set_ant_path(btcoexist,
2523 BTC_ANT_PATH_PTA, NORMAL_EXEC, false, false);
2524 halbtc8723b1ant_coex_table_with_type(btcoexist,
2525 NORMAL_EXEC, 4);
2526
2527 }
2528 }
2529 }
2530
2531 static
2532 void halbtc8723b1ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
2533 {
2534 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2535 boolean wifi_connected = false, bt_hs_on = false, wifi_busy = false;
2536 boolean increase_scan_dev_num = false;
2537 boolean bt_ctrl_agg_buf_size = false;
2538 boolean miracast_plus_bt = false;
2539 u8 agg_buf_size = 5;
2540 u32 wifi_link_status = 0;
2541 u32 num_of_wifi_link = 0, wifi_bw;
2542 u8 iot_peer = BTC_IOT_PEER_UNKNOWN;
2543
2544 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2545 "[BTCoex], RunCoexistMechanism()===>\n");
2546 BTC_TRACE(trace_buf);
2547
2548 if (btcoexist->manual_control) {
2549 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2550 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
2551 BTC_TRACE(trace_buf);
2552 return;
2553 }
2554
2555 if (btcoexist->stop_coex_dm) {
2556 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2557 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
2558 BTC_TRACE(trace_buf);
2559 return;
2560 }
2561
2562 if (coex_sta->under_ips) {
2563 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2564 "[BTCoex], wifi is under IPS !!!\n");
2565 BTC_TRACE(trace_buf);
2566 return;
2567 }
2568
2569 if (coex_sta->bt_whck_test) {
2570 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2571 "[BTCoex], BT is under WHCK TEST!!!\n");
2572 BTC_TRACE(trace_buf);
2573 halbtc8723b1ant_action_bt_whck_test(btcoexist);
2574 return;
2575 }
2576
2577 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
2578 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2579 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
2580 increase_scan_dev_num = true;
2581
2582 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
2583 &increase_scan_dev_num);
2584 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2585 &wifi_connected);
2586 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2587
2588 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2589 &wifi_link_status);
2590 num_of_wifi_link = wifi_link_status >> 16;
2591
2592 if ((num_of_wifi_link >= 2) ||
2593 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
2594 if (bt_link_info->bt_link_exist) {
2595 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1,
2596 0, 1);
2597 miracast_plus_bt = true;
2598 } else {
2599 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0,
2600 0, 0);
2601 miracast_plus_bt = false;
2602 }
2603 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2604 &miracast_plus_bt);
2605 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2606 bt_ctrl_agg_buf_size, agg_buf_size);
2607
2608 if (((bt_link_info->a2dp_exist) || (wifi_busy)) &&
2609 (coex_sta->c2h_bt_inquiry_page))
2610 halbtc8723b1ant_action_bt_inquiry(btcoexist);
2611 else
2612 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
2613
2614 return;
2615 }
2616
2617 miracast_plus_bt = false;
2618 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
2619 &miracast_plus_bt);
2620
2621 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2622
2623 if ((bt_link_info->bt_link_exist) && (wifi_connected)) {
2624 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1);
2625
2626 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer);
2627
2628 /* if(BTC_IOT_PEER_CISCO != iot_peer) */
2629 if ((BTC_IOT_PEER_CISCO != iot_peer) &&
2630 (BTC_IOT_PEER_BROADCOM != iot_peer)) {
2631 if (bt_link_info->sco_exist) /* if (bt_link_info->bt_hi_pri_link_exist) */
2632 /* halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, true, false, 0x5); */
2633 halbtc8723b1ant_limited_rx(btcoexist,
2634 NORMAL_EXEC, true, false, 0x5);
2635 else
2636 halbtc8723b1ant_limited_rx(btcoexist,
2637 NORMAL_EXEC, false, false, 0x5);
2638 /* halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x8); */
2639 } else {
2640 if (bt_link_info->sco_exist)
2641 halbtc8723b1ant_limited_rx(btcoexist,
2642 NORMAL_EXEC, true, false, 0x5);
2643 else if (bt_link_info->hid_exist)
2644 halbtc8723b1ant_limited_rx(btcoexist,
2645 NORMAL_EXEC, false, true, 0x8);
2646 else {
2647 if (BTC_WIFI_BW_HT40 == wifi_bw)
2648 halbtc8723b1ant_limited_rx(btcoexist,
2649 NORMAL_EXEC, false, true, 0x10);
2650 else
2651 halbtc8723b1ant_limited_rx(btcoexist,
2652 NORMAL_EXEC, false, true, 0x8);
2653 }
2654 }
2655
2656 halbtc8723b1ant_sw_mechanism(btcoexist, true);
2657
2658 /* low pelnaty ra in pcr ra */
2659 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 35);
2660
2661 } else {
2662 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2663
2664 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false,
2665 0x5);
2666
2667 halbtc8723b1ant_sw_mechanism(btcoexist, false);
2668 }
2669
2670 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2671 if (coex_sta->c2h_bt_inquiry_page) {
2672 halbtc8723b1ant_action_bt_inquiry(btcoexist);
2673 return;
2674 } else if (bt_hs_on) {
2675 halbtc8723b1ant_action_hs(btcoexist);
2676 return;
2677 }
2678
2679
2680 if (!wifi_connected) {
2681 boolean scan = false, link = false, roam = false;
2682
2683 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2684 "[BTCoex], wifi is non connected-idle !!!\n");
2685 BTC_TRACE(trace_buf);
2686
2687 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2688 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2689 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2690
2691 if (scan || link || roam) {
2692 if (scan)
2693 halbtc8723b1ant_action_wifi_not_connected_scan(
2694 btcoexist);
2695 else
2696 halbtc8723b1ant_action_wifi_not_connected_asso_auth(
2697 btcoexist);
2698 } else
2699 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
2700 } else /* wifi LPS/Busy */
2701 halbtc8723b1ant_action_wifi_connected(btcoexist);
2702 }
2703
2704 static
2705 void halbtc8723b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
2706 {
2707 /* force to reset coex mechanism */
2708
2709 /* sw all off */
2710 halbtc8723b1ant_sw_mechanism(btcoexist, false);
2711
2712 /* halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); */
2713 /* halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); */
2714
2715 coex_sta->pop_event_cnt = 0;
2716 }
2717
2718 static
2719 void halbtc8723b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
2720 IN boolean back_up, IN boolean wifi_only)
2721 {
2722 u32 u32tmp = 0; /* , fw_ver; */
2723 u8 u8tmpa = 0, u8tmpb = 0;
2724
2725 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2726 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2727 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2728
2729 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2730 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x (before init hw config)\n",
2731 u32tmp, u8tmpa, u8tmpb);
2732 BTC_TRACE(trace_buf);
2733
2734
2735 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2736 "[BTCoex], 1Ant Init HW Config!!\n");
2737 BTC_TRACE(trace_buf);
2738
2739 psd_scan->ant_det_is_ant_det_available = false;
2740
2741
2742 /* Give bt_coex_supported_version the default value */
2743 coex_sta->bt_coex_supported_version = 0;
2744
2745 /* 0xf0[15:12] --> Chip Cut information */
2746 coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
2747 0xf1) & 0xf0) >> 4;
2748
2749 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
2750 0x1); /* enable TBTT nterrupt */
2751
2752 /* 0x790[5:0]=0x5 */
2753 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
2754
2755 /* Enable counter statistics */
2756 /* btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); */ /*0x76e[3] =1, WLAN_Act control by PTA */
2757 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
2758 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2759
2760
2761 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1); */ /*BT select s0/s1 is controlled by WiFi */
2762
2763 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2764
2765 /* Antenna config */
2766 if (wifi_only)
2767 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
2768 FORCE_EXEC, true, false);
2769 else
2770 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2771 FORCE_EXEC, true, false);
2772
2773 /* PTA parameter */
2774 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2775
2776 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
2777 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
2778 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
2779
2780 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2781 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x (after init hw config)\n",
2782 u32tmp, u8tmpa, u8tmpb);
2783 BTC_TRACE(trace_buf);
2784
2785 }
2786
2787 /* Donot remove optimize off flag, otherwise antenna detection would trigger BT collapsed */
2788 #ifdef PLATFORM_WINDOWS
2789 #pragma optimize("", off)
2790 #endif
2791
2792 static
2793 void halbtc8723b1ant_mechanism_switch(IN struct btc_coexist *btcoexist,
2794 IN boolean bSwitchTo2Antenna)
2795 {
2796
2797 if (bSwitchTo2Antenna) {
2798
2799 /* BT TRx mask off */
2800 btcoexist->btc_set_bt_trx_mask(btcoexist, 0);
2801
2802 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2803 "############# [BTCoex], BT TRx Mask off for mechanism_switch\n");
2804
2805 BTC_TRACE(trace_buf);
2806
2807 } else {
2808
2809 /* BT TRx mask on */
2810 btcoexist->btc_set_bt_trx_mask(btcoexist, 1);
2811
2812 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2813 "############# [BTCoex], BT TRx Mask on for mechanism_switch\n");
2814
2815 BTC_TRACE(trace_buf);
2816 }
2817
2818
2819 #if 0
2820 if (bSwitchTo2Antenna) { /* 1-Ant -> 2-Ant */
2821 /* un-lock TRx Mask setup for 8723b f-cut */
2822 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd, 0x80, 0x1);
2823 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf, 0x1, 0x1);
2824 /* WiFi TRx Mask on */
2825 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2826 0x0);
2827
2828 /* BT TRx Mask un-lock 0x2c[0], 0x30[0] = 1 */
2829 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x2c,
2830 0x7c45);
2831 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x30,
2832 0x7c45);
2833
2834 /* BT TRx Mask on */
2835 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x1);
2836
2837 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2838 FORCE_EXEC, false, false);
2839 } else {
2840 /* WiFi TRx Mask on */
2841 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2842 0x780);
2843
2844 /* lock TRx Mask setup for 8723b f-cut */
2845 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd, 0x80, 0x0);
2846 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf, 0x1, 0x0);
2847
2848 /* BT TRx Mask on */
2849 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x3c, 0x15);
2850
2851 /* BT TRx Mask ock 0x2c[0], 0x30[0] = 0 */
2852 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x2c,
2853 0x7c44);
2854 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 0x30,
2855 0x7c44);
2856
2857
2858 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2859 FORCE_EXEC, false, false);
2860 }
2861
2862 #endif
2863 }
2864
2865 static
2866 u32 halbtc8723b1ant_psd_log2base(IN struct btc_coexist *btcoexist, IN u32 val)
2867 {
2868 u8 j;
2869 u32 tmp, tmp2, val_integerd_b = 0, tindex, shiftcount = 0;
2870 u32 result, val_fractiond_b = 0, table_fraction[21] = {0, 432, 332, 274, 232, 200,
2871 174, 151, 132, 115, 100, 86, 74, 62, 51, 42,
2872 32, 23, 15, 7, 0
2873 };
2874
2875 if (val == 0)
2876 return 0;
2877
2878 tmp = val;
2879
2880 while (1) {
2881 if (tmp == 1)
2882 break;
2883
2884 tmp = (tmp >> 1);
2885 shiftcount++;
2886 }
2887
2888
2889 val_integerd_b = shiftcount + 1;
2890
2891 tmp2 = 1;
2892 for (j = 1; j <= val_integerd_b; j++)
2893 tmp2 = tmp2 * 2;
2894
2895 tmp = (val * 100) / tmp2;
2896 tindex = tmp / 5;
2897
2898 if (tindex > 20)
2899 tindex = 20;
2900
2901 val_fractiond_b = table_fraction[tindex];
2902
2903 result = val_integerd_b * 100 - val_fractiond_b;
2904
2905 return result;
2906
2907
2908 }
2909
2910 static
2911 void halbtc8723b1ant_psd_show_antenna_detect_result(IN struct btc_coexist
2912 *btcoexist)
2913 {
2914 u8 *cli_buf = btcoexist->cli_buf;
2915 struct btc_board_info *board_info = &btcoexist->board_info;
2916
2917 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2918 "\r\n============[Antenna Detection info] ============\n");
2919 CL_PRINTF(cli_buf);
2920
2921 if (psd_scan->ant_det_result == 1)
2922 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (>%d)",
2923 "Ant Det Result", "2-Antenna (Bad-Isolation)",
2924 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
2925 else if (psd_scan->ant_det_result == 2)
2926 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
2927 "Ant Det Result", "2-Antenna (Good-Isolation)",
2928 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
2929 + psd_scan->ant_det_thres_offset,
2930 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
2931 else
2932 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
2933 "Ant Det Result", "1-Antenna",
2934 BT_8723B_1ANT_ANTDET_PSDTHRES_1ANT,
2935 BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
2936 + psd_scan->ant_det_thres_offset);
2937
2938 CL_PRINTF(cli_buf);
2939
2940 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s ",
2941 "Antenna Detection Finish",
2942 (board_info->btdm_ant_det_finish
2943 ? "Yes" : "No"));
2944 CL_PRINTF(cli_buf);
2945
2946 switch (psd_scan->ant_det_result) {
2947 case 0:
2948 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2949 "(BT is not available)");
2950 break;
2951 case 1: /* 2-Ant bad-isolation */
2952 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2953 "(BT is available)");
2954 break;
2955 case 2: /* 2-Ant good-isolation */
2956 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2957 "(BT is available)");
2958 break;
2959 case 3: /* 1-Ant */
2960 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2961 "(BT is available)");
2962 break;
2963 case 4:
2964 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2965 "(Uncertainty result)");
2966 break;
2967 case 5:
2968 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "(Pre-Scan fai)");
2969 break;
2970 case 6:
2971 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2972 "(WiFi is Scanning)");
2973 break;
2974 case 7:
2975 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2976 "(BT is not idle)");
2977 break;
2978 case 8:
2979 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2980 "(Abort by WiFi Scanning)");
2981 break;
2982 case 9:
2983 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2984 "(Antenna Init is not ready)");
2985 break;
2986 case 10:
2987 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2988 "(BT is Inquiry or page)");
2989 break;
2990 case 11:
2991 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
2992 "(BT is Disabled)");
2993 break;
2994 }
2995 CL_PRINTF(cli_buf);
2996
2997
2998 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
2999 "Ant Detect Total Count", psd_scan->ant_det_try_count);
3000 CL_PRINTF(cli_buf);
3001
3002 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
3003 "Ant Detect Fail Count", psd_scan->ant_det_fail_count);
3004 CL_PRINTF(cli_buf);
3005
3006 if ((!board_info->btdm_ant_det_finish) &&
3007 (psd_scan->ant_det_result != 5))
3008 return;
3009
3010 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Response",
3011 (psd_scan->ant_det_result ? "ok" : "fail"));
3012 CL_PRINTF(cli_buf);
3013
3014 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ms", "BT Tx Time",
3015 psd_scan->ant_det_bt_tx_time);
3016 CL_PRINTF(cli_buf);
3017
3018 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "BT Tx Ch",
3019 psd_scan->ant_det_bt_le_channel);
3020 CL_PRINTF(cli_buf);
3021
3022 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
3023 "WiFi PSD Cent-Ch/Offset/Span",
3024 psd_scan->real_cent_freq, psd_scan->real_offset,
3025 psd_scan->real_span);
3026 CL_PRINTF(cli_buf);
3027
3028 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
3029 "PSD Pre-Scan Peak Value",
3030 psd_scan->ant_det_pre_psdscan_peak_val / 100);
3031 CL_PRINTF(cli_buf);
3032
3033 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (<= %d)",
3034 "PSD Pre-Scan result",
3035 (psd_scan->ant_det_result != 5 ? "ok" : "fail"),
3036 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
3037 + psd_scan->ant_det_thres_offset);
3038 CL_PRINTF(cli_buf);
3039
3040 if (psd_scan->ant_det_result == 5)
3041 return;
3042
3043 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s dB",
3044 "PSD Scan Peak Value", psd_scan->ant_det_peak_val);
3045 CL_PRINTF(cli_buf);
3046
3047 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s MHz",
3048 "PSD Scan Peak Freq", psd_scan->ant_det_peak_freq);
3049 CL_PRINTF(cli_buf);
3050
3051
3052 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "TFBGA Package",
3053 (board_info->tfbga_package) ? "Yes" : "No");
3054 CL_PRINTF(cli_buf);
3055
3056 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
3057 "PSD Threshold Offset", psd_scan->ant_det_thres_offset);
3058 CL_PRINTF(cli_buf);
3059
3060 }
3061
3062 static
3063 void halbtc8723b1ant_psd_showdata(IN struct btc_coexist *btcoexist)
3064 {
3065 u8 *cli_buf = btcoexist->cli_buf;
3066 u32 delta_freq_per_point;
3067 u32 freq, freq1, freq2, n = 0, i = 0, j = 0, m = 0, psd_rep1, psd_rep2;
3068
3069 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3070 "\r\n\n============[PSD info] (%d)============\n",
3071 psd_scan->psd_gen_count);
3072 CL_PRINTF(cli_buf);
3073
3074 if (psd_scan->psd_gen_count == 0) {
3075 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n No data !!\n");
3076 CL_PRINTF(cli_buf);
3077 return;
3078 }
3079
3080 if (psd_scan->psd_point == 0)
3081 delta_freq_per_point = 0;
3082 else
3083 delta_freq_per_point = psd_scan->psd_band_width /
3084 psd_scan->psd_point;
3085
3086 /* if (psd_scan->is_psd_show_max_only) */
3087 if (0) {
3088 psd_rep1 = psd_scan->psd_max_value / 100;
3089 psd_rep2 = psd_scan->psd_max_value - psd_rep1 * 100;
3090
3091 freq = ((psd_scan->real_cent_freq - 20) * 1000000 +
3092 psd_scan->psd_max_value_point * delta_freq_per_point);
3093 freq1 = freq / 1000000;
3094 freq2 = freq / 1000 - freq1 * 1000;
3095
3096 if (freq2 < 100)
3097 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3098 "\r\n Freq = %d.0%d MHz",
3099 freq1, freq2);
3100 else
3101 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3102 "\r\n Freq = %d.%d MHz",
3103 freq1, freq2);
3104
3105 if (psd_rep2 < 10)
3106 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3107 ", Value = %d.0%d dB, (%d)\n",
3108 psd_rep1, psd_rep2, psd_scan->psd_max_value);
3109 else
3110 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3111 ", Value = %d.%d dB, (%d)\n",
3112 psd_rep1, psd_rep2, psd_scan->psd_max_value);
3113
3114 CL_PRINTF(cli_buf);
3115 } else {
3116 m = psd_scan->psd_start_point;
3117 n = psd_scan->psd_start_point;
3118 i = 1;
3119 j = 1;
3120
3121 while (1) {
3122 do {
3123 freq = ((psd_scan->real_cent_freq - 20) *
3124 1000000 + m *
3125 delta_freq_per_point);
3126 freq1 = freq / 1000000;
3127 freq2 = freq / 1000 - freq1 * 1000;
3128
3129 if (i == 1) {
3130 if (freq2 == 0)
3131 CL_SPRINTF(cli_buf,
3132 BT_TMP_BUF_SIZE,
3133 "\r\n Freq%6d.000",
3134 freq1);
3135 else if (freq2 < 100)
3136 CL_SPRINTF(cli_buf,
3137 BT_TMP_BUF_SIZE,
3138 "\r\n Freq%6d.0%2d",
3139 freq1,
3140 freq2);
3141 else
3142 CL_SPRINTF(cli_buf,
3143 BT_TMP_BUF_SIZE,
3144 "\r\n Freq%6d.%3d",
3145 freq1,
3146 freq2);
3147 } else if ((i % 8 == 0) ||
3148 (m == psd_scan->psd_stop_point)) {
3149 if (freq2 == 0)
3150 CL_SPRINTF(cli_buf,
3151 BT_TMP_BUF_SIZE,
3152 "%6d.000\n", freq1);
3153 else if (freq2 < 100)
3154 CL_SPRINTF(cli_buf,
3155 BT_TMP_BUF_SIZE,
3156 "%6d.0%2d\n", freq1,
3157 freq2);
3158 else
3159 CL_SPRINTF(cli_buf,
3160 BT_TMP_BUF_SIZE,
3161 "%6d.%3d\n", freq1,
3162 freq2);
3163 } else {
3164 if (freq2 == 0)
3165 CL_SPRINTF(cli_buf,
3166 BT_TMP_BUF_SIZE,
3167 "%6d.000", freq1);
3168 else if (freq2 < 100)
3169 CL_SPRINTF(cli_buf,
3170 BT_TMP_BUF_SIZE,
3171 "%6d.0%2d", freq1,
3172 freq2);
3173 else
3174 CL_SPRINTF(cli_buf,
3175 BT_TMP_BUF_SIZE,
3176 "%6d.%3d", freq1,
3177 freq2);
3178 }
3179
3180 i++;
3181 m++;
3182 CL_PRINTF(cli_buf);
3183
3184 } while ((i <= 8) && (m <= psd_scan->psd_stop_point));
3185
3186
3187 do {
3188 psd_rep1 = psd_scan->psd_report_max_hold[n] /
3189 100;
3190 psd_rep2 = psd_scan->psd_report_max_hold[n] -
3191 psd_rep1 *
3192 100;
3193
3194 if (j == 1) {
3195 if (psd_rep2 < 10)
3196 CL_SPRINTF(cli_buf,
3197 BT_TMP_BUF_SIZE,
3198 "\r\n Val %7d.0%d",
3199 psd_rep1,
3200 psd_rep2);
3201 else
3202 CL_SPRINTF(cli_buf,
3203 BT_TMP_BUF_SIZE,
3204 "\r\n Val %7d.%d",
3205 psd_rep1,
3206 psd_rep2);
3207 } else if ((j % 8 == 0) ||
3208 (n == psd_scan->psd_stop_point)) {
3209 if (psd_rep2 < 10)
3210 CL_SPRINTF(cli_buf,
3211 BT_TMP_BUF_SIZE,
3212 "%7d.0%d\n", psd_rep1,
3213 psd_rep2);
3214 else
3215 CL_SPRINTF(cli_buf,
3216 BT_TMP_BUF_SIZE,
3217 "%7d.%d\n", psd_rep1,
3218 psd_rep2);
3219 } else {
3220 if (psd_rep2 < 10)
3221 CL_SPRINTF(cli_buf,
3222 BT_TMP_BUF_SIZE,
3223 "%7d.0%d", psd_rep1,
3224 psd_rep2);
3225 else
3226 CL_SPRINTF(cli_buf,
3227 BT_TMP_BUF_SIZE,
3228 "%7d.%d", psd_rep1,
3229 psd_rep2);
3230 }
3231
3232 j++;
3233 n++;
3234 CL_PRINTF(cli_buf);
3235
3236 } while ((j <= 8) && (n <= psd_scan->psd_stop_point));
3237
3238 if ((m > psd_scan->psd_stop_point) ||
3239 (n > psd_scan->psd_stop_point))
3240 break;
3241
3242 i = 1;
3243 j = 1;
3244 }
3245 }
3246
3247
3248 }
3249
3250 static
3251 void halbtc8723b1ant_psd_max_holddata(IN struct btc_coexist *btcoexist,
3252 IN u32 gen_count)
3253 {
3254 u32 i = 0, i_max = 0, val_max = 0;
3255
3256 if (gen_count == 1) {
3257 memcpy(psd_scan->psd_report_max_hold,
3258 psd_scan->psd_report,
3259 BT_8723B_1ANT_ANTDET_PSD_POINTS * sizeof(u32));
3260
3261 psd_scan->psd_max_value_point = 0;
3262 psd_scan->psd_max_value = 0;
3263
3264 } else {
3265 for (i = psd_scan->psd_start_point;
3266 i <= psd_scan->psd_stop_point; i++) {
3267 if (psd_scan->psd_report[i] >
3268 psd_scan->psd_report_max_hold[i])
3269 psd_scan->psd_report_max_hold[i] =
3270 psd_scan->psd_report[i];
3271
3272 /* search Max Value */
3273 if (i == psd_scan->psd_start_point) {
3274 i_max = i;
3275 val_max = psd_scan->psd_report_max_hold[i];
3276 } else {
3277 if (psd_scan->psd_report_max_hold[i] >
3278 val_max) {
3279 i_max = i;
3280 val_max = psd_scan->psd_report_max_hold[i];
3281 }
3282 }
3283
3284 }
3285
3286 psd_scan->psd_max_value_point = i_max;
3287 psd_scan->psd_max_value = val_max;
3288
3289 }
3290
3291
3292 }
3293
3294 static
3295 u32 halbtc8723b1ant_psd_getdata(IN struct btc_coexist *btcoexist, IN u32 point)
3296 {
3297 /* reg 0x808[9:0]: FFT data x */
3298 /* reg 0x808[22]: 0-->1 to get 1 FFT data y */
3299 /* reg 0x8b4[15:0]: FFT data y report */
3300
3301 u32 val = 0, psd_report = 0;
3302 int k = 0;
3303
3304 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
3305
3306 val &= 0xffbffc00;
3307 val |= point;
3308
3309 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
3310
3311 val |= 0x00400000;
3312 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
3313
3314 while (1) {
3315 if (k++ > BT_8723B_1ANT_ANTDET_SWEEPPOINT_DELAY)
3316 break;
3317 }
3318
3319 val = btcoexist->btc_read_4byte(btcoexist, 0x8b4);
3320
3321 psd_report = val & 0x0000ffff;
3322
3323 return psd_report;
3324 }
3325
3326 static
3327 boolean halbtc8723b1ant_psd_sweep_point(IN struct btc_coexist *btcoexist,
3328 IN u32 cent_freq, IN s32 offset, IN u32 span, IN u32 points,
3329 IN u32 avgnum, IN u32 loopcnt)
3330 {
3331 u32 i, val, n, k = 0, j, point_index = 0;
3332 u32 points1 = 0, psd_report = 0;
3333 u32 start_p = 0, stop_p = 0, delta_freq_per_point = 156250;
3334 u32 psd_center_freq = 20 * 10 ^ 6;
3335 boolean outloop = false, scan , roam, is_sweep_ok = true;
3336 u8 flag = 0;
3337 u32 tmp;
3338 u32 wifi_original_channel = 1;
3339
3340 psd_scan->is_psd_running = true;
3341 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3342 "xxxxxxxxxxxxxxxx PSD Sweep Start!!\n");
3343 BTC_TRACE(trace_buf);
3344
3345 do {
3346 switch (flag) {
3347 case 0: /* Get PSD parameters */
3348 default:
3349
3350 psd_scan->psd_band_width = 40 * 1000000;
3351 psd_scan->psd_point = points;
3352 psd_scan->psd_start_base = points / 2;
3353 psd_scan->psd_avg_num = avgnum;
3354 psd_scan->real_cent_freq = cent_freq;
3355 psd_scan->real_offset = offset;
3356 psd_scan->real_span = span;
3357
3358
3359 points1 = psd_scan->psd_point;
3360 delta_freq_per_point = psd_scan->psd_band_width /
3361 psd_scan->psd_point;
3362
3363 /* PSD point setup */
3364 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
3365 val &= 0xffff0fff;
3366
3367 switch (psd_scan->psd_point) {
3368 case 128:
3369 val |= 0x0;
3370 break;
3371 case 256:
3372 default:
3373 val |= 0x00004000;
3374 break;
3375 case 512:
3376 val |= 0x00008000;
3377 break;
3378 case 1024:
3379 val |= 0x0000c000;
3380 break;
3381 }
3382
3383 switch (psd_scan->psd_avg_num) {
3384 case 1:
3385 val |= 0x0;
3386 break;
3387 case 8:
3388 val |= 0x00001000;
3389 break;
3390 case 16:
3391 val |= 0x00002000;
3392 break;
3393 case 32:
3394 default:
3395 val |= 0x00003000;
3396 break;
3397 }
3398 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
3399
3400 flag = 1;
3401 break;
3402 case 1: /* calculate the PSD point index from freq/offset/span */
3403 psd_center_freq = psd_scan->psd_band_width / 2 +
3404 offset * (1000000);
3405
3406 start_p = psd_scan->psd_start_base + (psd_center_freq -
3407 span * (1000000) / 2) / delta_freq_per_point;
3408 psd_scan->psd_start_point = start_p -
3409 psd_scan->psd_start_base;
3410
3411 stop_p = psd_scan->psd_start_base + (psd_center_freq +
3412 span * (1000000) / 2) / delta_freq_per_point;
3413 psd_scan->psd_stop_point = stop_p -
3414 psd_scan->psd_start_base - 1;
3415
3416 flag = 2;
3417 break;
3418 case 2: /* set RF channel/BW/Mode */
3419
3420 /* set 3-wire off */
3421 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
3422 val |= 0x00300000;
3423 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
3424
3425 /* CCK off */
3426 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
3427 val &= 0xfeffffff;
3428 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
3429
3430 /* store WiFi original channel */
3431 wifi_original_channel = btcoexist->btc_get_rf_reg(
3432 btcoexist, BTC_RF_A, 0x18, 0x3ff);
3433
3434 /* Set RF channel */
3435 if (cent_freq == 2484)
3436 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
3437 0x18, 0x3ff, 0xe);
3438 else
3439 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
3440 0x18, 0x3ff, (cent_freq - 2412) / 5 +
3441 1); /* WiFi TRx Mask on */
3442
3443
3444 /* Set RF Rx filter corner */
3445 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
3446 0xfffff, 0x3e4);
3447
3448 /* Set TRx mask off */
3449 /* un-lock TRx Mask setup */
3450 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd,
3451 0x80, 0x1);
3452 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf,
3453 0x1, 0x1);
3454
3455 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3456 0xfffff, 0x0);
3457
3458 /* Set RF mode = Rx, RF Gain = 0x8a0 */
3459 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x0,
3460 0xfffff, 0x308a0);
3461
3462 while (1) {
3463 if (k++ > BT_8723B_1ANT_ANTDET_SWEEPPOINT_DELAY)
3464 break;
3465 }
3466 flag = 3;
3467 break;
3468 case 3:
3469 psd_scan->psd_gen_count = 0;
3470 for (j = 1; j <= loopcnt; j++) {
3471
3472 btcoexist->btc_get(btcoexist,
3473 BTC_GET_BL_WIFI_SCAN, &scan);
3474 btcoexist->btc_get(btcoexist,
3475 BTC_GET_BL_WIFI_ROAM, &roam);
3476
3477 if (scan || roam) {
3478 is_sweep_ok = false;
3479 break;
3480 }
3481 memset(psd_scan->psd_report, 0,
3482 psd_scan->psd_point * sizeof(u32));
3483 start_p = psd_scan->psd_start_point +
3484 psd_scan->psd_start_base;
3485 stop_p = psd_scan->psd_stop_point +
3486 psd_scan->psd_start_base + 1;
3487
3488 i = start_p;
3489 point_index = 0;
3490
3491 while (i < stop_p) {
3492 if (i >= points1)
3493 psd_report =
3494 halbtc8723b1ant_psd_getdata(
3495 btcoexist, i - points1);
3496 else
3497 psd_report =
3498 halbtc8723b1ant_psd_getdata(
3499 btcoexist, i);
3500
3501 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3502 "Point=%d, psd_raw_data = 0x%08x\n",
3503 i, psd_report);
3504 BTC_TRACE(trace_buf);
3505 if (psd_report == 0)
3506 tmp = 0;
3507 else
3508 /* tmp = 20*log10((double)psd_report); */
3509 /* 20*log2(x)/log2(10), log2Base return theresult of the psd_report*100 */
3510 tmp = 6 * halbtc8723b1ant_psd_log2base(
3511 btcoexist, psd_report);
3512
3513 n = i - psd_scan->psd_start_base;
3514 psd_scan->psd_report[n] = tmp;
3515
3516
3517 halbtc8723b1ant_psd_max_holddata(
3518 btcoexist, j);
3519
3520 i++;
3521
3522 }
3523
3524 psd_scan->psd_gen_count = j;
3525 }
3526
3527 flag = 100;
3528 break;
3529 case 99: /* error */
3530
3531 outloop = true;
3532 break;
3533 case 100: /* recovery */
3534
3535 /* set 3-wire on */
3536 val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
3537 val &= 0xffcfffff;
3538 btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
3539
3540 /* CCK on */
3541 val = btcoexist->btc_read_4byte(btcoexist, 0x800);
3542 val |= 0x01000000;
3543 btcoexist->btc_write_4byte(btcoexist, 0x800, val);
3544
3545 /* PSD off */
3546 val = btcoexist->btc_read_4byte(btcoexist, 0x808);
3547 val &= 0xffbfffff;
3548 btcoexist->btc_write_4byte(btcoexist, 0x808, val);
3549
3550 /* TRx Mask on */
3551 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3552 0xfffff, 0x780);
3553
3554 /* lock TRx Mask setup */
3555 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdd,
3556 0x80, 0x0);
3557 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xdf,
3558 0x1, 0x0);
3559
3560 /* Set RF Rx filter corner */
3561 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
3562 0xfffff, 0x0);
3563
3564 /* restore WiFi original channel */
3565 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x18,
3566 0x3ff, wifi_original_channel);
3567
3568 outloop = true;
3569 break;
3570
3571 }
3572
3573 } while (!outloop);
3574
3575
3576
3577 psd_scan->is_psd_running = false;
3578
3579 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3580 "xxxxxxxxxxxxxxxx PSD Sweep Stop!!\n");
3581 BTC_TRACE(trace_buf);
3582 return is_sweep_ok;
3583
3584 }
3585
3586 static
3587 void halbtc8723b1ant_psd_antenna_detection(IN struct btc_coexist *btcoexist,
3588 IN u32 bt_tx_time, IN u32 bt_le_channel)
3589 {
3590 u32 i = 0;
3591 u32 wlpsd_cent_freq = 2484, wlpsd_span = 2, wlpsd_sweep_count = 50;
3592 s32 wlpsd_offset = -4;
3593 u8 bt_le_ch[13] = {3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 33};
3594
3595 u8 h2c_parameter[3] = {0}, u8tmpa, u8tmpb;
3596
3597 u8 state = 0;
3598 boolean outloop = false, bt_resp = false;
3599 u32 freq, freq1, freq2, psd_rep1, psd_rep2, delta_freq_per_point,
3600 u32tmp;
3601 struct btc_board_info *board_info = &btcoexist->board_info;
3602
3603 board_info->btdm_ant_det_finish = false;
3604 memset(psd_scan->ant_det_peak_val, 0, 16 * sizeof(u8));
3605 memset(psd_scan->ant_det_peak_freq, 0, 16 * sizeof(u8));
3606
3607 if (board_info->tfbga_package) /* for TFBGA */
3608 psd_scan->ant_det_thres_offset = 5;
3609 else
3610 psd_scan->ant_det_thres_offset = 0;
3611
3612 do {
3613 switch (state) {
3614 case 0:
3615 if (bt_le_channel == 39)
3616 wlpsd_cent_freq = 2484;
3617 else {
3618 for (i = 1; i <= 13; i++) {
3619 if (bt_le_ch[i - 1] ==
3620 bt_le_channel) {
3621 wlpsd_cent_freq = 2412
3622 + (i - 1) * 5;
3623 break;
3624 }
3625 }
3626
3627 if (i == 14) {
3628
3629 BTC_SPRINTF(trace_buf,
3630 BT_TMP_BUF_SIZE,
3631 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort!!, Invalid LE channel = %d\n ",
3632 bt_le_channel);
3633 BTC_TRACE(trace_buf);
3634 outloop = true;
3635 break;
3636 }
3637 }
3638
3639 wlpsd_sweep_count = bt_tx_time * 238 /
3640 100; /* bt_tx_time/0.42 */
3641 wlpsd_sweep_count = wlpsd_sweep_count / 5;
3642
3643 if (wlpsd_sweep_count % 5 != 0)
3644 wlpsd_sweep_count = (wlpsd_sweep_count /
3645 5 + 1) * 5;
3646
3647 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3648 "xxxxxxxxxxxxxxxx AntennaDetect(), BT_LETxTime=%d, BT_LECh = %d\n",
3649 bt_tx_time, bt_le_channel);
3650 BTC_TRACE(trace_buf);
3651 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3652 "xxxxxxxxxxxxxxxx AntennaDetect(), wlpsd_cent_freq=%d, wlpsd_offset = %d, wlpsd_span = %d, wlpsd_sweep_count = %d\n",
3653 wlpsd_cent_freq,
3654 wlpsd_offset,
3655 wlpsd_span,
3656 wlpsd_sweep_count);
3657 BTC_TRACE(trace_buf);
3658
3659 state = 1;
3660 break;
3661 case 1: /* stop coex DM & set antenna path */
3662 /* Stop Coex DM */
3663
3664 /*
3665 btcoexist->stop_coex_dm = true;
3666
3667 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3668 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
3669 BTC_TRACE(trace_buf); */
3670
3671 /* Set TDMA off, */
3672 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC,
3673 false, 0);
3674
3675 /* Set coex table */
3676 halbtc8723b1ant_coex_table_with_type(btcoexist,
3677 FORCE_EXEC, 0);
3678
3679 if (board_info->btdm_ant_pos ==
3680 BTC_ANTENNA_AT_MAIN_PORT) {
3681 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3682 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Main Port\n");
3683 BTC_TRACE(trace_buf);
3684 } else {
3685 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3686 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Aux Port\n");
3687 BTC_TRACE(trace_buf);
3688 }
3689
3690 /* Set Antenna path, switch WiFi to un-certain antenna port */
3691 halbtc8723b1ant_set_ant_path(btcoexist,
3692 BTC_ANT_PATH_BT, FORCE_EXEC, false,
3693 false);
3694
3695 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3696 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to BT!!\n");
3697 BTC_TRACE(trace_buf);
3698
3699 /* Set AFH mask on at WiFi channel 2472MHz +/- 10MHz */
3700 h2c_parameter[0] = 0x1;
3701 h2c_parameter[1] = 0xd;
3702 h2c_parameter[2] = 0x14;
3703
3704 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3705 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
3706 h2c_parameter[1],
3707 h2c_parameter[2]);
3708 BTC_TRACE(trace_buf);
3709
3710 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
3711 h2c_parameter);
3712
3713 u32tmp = btcoexist->btc_read_4byte(btcoexist,
3714 0x948);
3715 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
3716 u8tmpb = btcoexist->btc_read_1byte(btcoexist,
3717 0x778);
3718
3719 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3720 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x778=0x%x\n",
3721 u32tmp, u8tmpa, u8tmpb);
3722 BTC_TRACE(trace_buf);
3723
3724 state = 2;
3725 break;
3726 case 2: /* Pre-sweep background psd */
3727 if (!halbtc8723b1ant_psd_sweep_point(btcoexist,
3728 wlpsd_cent_freq, wlpsd_offset, wlpsd_span,
3729 BT_8723B_1ANT_ANTDET_PSD_POINTS,
3730 BT_8723B_1ANT_ANTDET_PSD_AVGNUM, 3)) {
3731 board_info->btdm_ant_det_finish = false;
3732 board_info->btdm_ant_num_by_ant_det = 1;
3733 psd_scan->ant_det_result = 8;
3734 state = 99;
3735 break;
3736 }
3737
3738 psd_scan->ant_det_pre_psdscan_peak_val =
3739 psd_scan->psd_max_value;
3740
3741 if (psd_scan->psd_max_value >
3742 (BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
3743 + psd_scan->ant_det_thres_offset) * 100) {
3744 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3745 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort Antenna Detection!! becaus background = %d > thres (%d)\n",
3746 psd_scan->psd_max_value / 100,
3747 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
3748 + psd_scan->ant_det_thres_offset);
3749 BTC_TRACE(trace_buf);
3750 board_info->btdm_ant_det_finish = false;
3751 board_info->btdm_ant_num_by_ant_det = 1;
3752 psd_scan->ant_det_result = 5;
3753 state = 99;
3754 } else {
3755 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3756 "xxxxxxxxxxxxxxxx AntennaDetect(), Start Antenna Detection!! becaus background = %d <= thres (%d)\n",
3757 psd_scan->psd_max_value / 100,
3758 BT_8723B_1ANT_ANTDET_PSDTHRES_BACKGROUND
3759 + psd_scan->ant_det_thres_offset);
3760 BTC_TRACE(trace_buf);
3761 state = 3;
3762 }
3763 break;
3764 case 3:
3765 bt_resp = btcoexist->btc_set_bt_ant_detection(
3766 btcoexist, (u8)(bt_tx_time & 0xff),
3767 (u8)(bt_le_channel & 0xff));
3768
3769 if (!halbtc8723b1ant_psd_sweep_point(btcoexist,
3770 wlpsd_cent_freq, wlpsd_offset,
3771 wlpsd_span,
3772 BT_8723B_1ANT_ANTDET_PSD_POINTS,
3773 BT_8723B_1ANT_ANTDET_PSD_AVGNUM,
3774 wlpsd_sweep_count)) {
3775 board_info->btdm_ant_det_finish = false;
3776 board_info->btdm_ant_num_by_ant_det = 1;
3777 psd_scan->ant_det_result = 8;
3778 state = 99;
3779 break;
3780 }
3781
3782 psd_scan->ant_det_psd_scan_peak_val =
3783 psd_scan->psd_max_value;
3784 psd_scan->ant_det_psd_scan_peak_freq =
3785 psd_scan->psd_max_value_point;
3786 state = 4;
3787 break;
3788 case 4:
3789
3790 if (psd_scan->psd_point == 0)
3791 delta_freq_per_point = 0;
3792 else
3793 delta_freq_per_point =
3794 psd_scan->psd_band_width /
3795 psd_scan->psd_point;
3796
3797 psd_rep1 = psd_scan->psd_max_value / 100;
3798 psd_rep2 = psd_scan->psd_max_value - psd_rep1 *
3799 100;
3800
3801 freq = ((psd_scan->real_cent_freq - 20) *
3802 1000000 + psd_scan->psd_max_value_point
3803 * delta_freq_per_point);
3804 freq1 = freq / 1000000;
3805 freq2 = freq / 1000 - freq1 * 1000;
3806
3807 if (freq2 < 100) {
3808 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3809 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.0%d MHz",
3810 freq1, freq2);
3811 BTC_TRACE(trace_buf);
3812 CL_SPRINTF(psd_scan->ant_det_peak_freq,
3813 BT_8723B_1ANT_ANTDET_BUF_LEN,
3814 "%d.0%d", freq1, freq2);
3815 } else {
3816 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3817 "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.%d MHz",
3818 freq1, freq2);
3819 BTC_TRACE(trace_buf);
3820 CL_SPRINTF(psd_scan->ant_det_peak_freq,
3821 BT_8723B_1ANT_ANTDET_BUF_LEN,
3822 "%d.%d", freq1, freq2);
3823 }
3824
3825 if (psd_rep2 < 10) {
3826 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3827 ", Value = %d.0%d dB\n",
3828 psd_rep1, psd_rep2);
3829 BTC_TRACE(trace_buf);
3830 CL_SPRINTF(psd_scan->ant_det_peak_val,
3831 BT_8723B_1ANT_ANTDET_BUF_LEN,
3832 "%d.0%d", psd_rep1, psd_rep2);
3833 } else {
3834 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3835 ", Value = %d.%d dB\n",
3836 psd_rep1, psd_rep2);
3837 BTC_TRACE(trace_buf);
3838 CL_SPRINTF(psd_scan->ant_det_peak_val,
3839 BT_8723B_1ANT_ANTDET_BUF_LEN,
3840 "%d.%d", psd_rep1, psd_rep2);
3841 }
3842
3843 psd_scan->ant_det_is_btreply_available = true;
3844
3845 if (bt_resp == false) {
3846 psd_scan->ant_det_is_btreply_available =
3847 false;
3848 psd_scan->ant_det_result = 0;
3849 board_info->btdm_ant_det_finish = false;
3850 board_info->btdm_ant_num_by_ant_det = 1;
3851 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3852 "xxxxxxxxxxxxxxxx AntennaDetect(), BT Response = Fail\n ");
3853 BTC_TRACE(trace_buf);
3854 } else if (psd_scan->psd_max_value >
3855 (BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
3856 * 100) {
3857 psd_scan->ant_det_result = 1;
3858 board_info->btdm_ant_det_finish = true;
3859 board_info->btdm_ant_det_already_init_phydm =
3860 true;
3861 board_info->btdm_ant_num_by_ant_det = 2;
3862 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3863 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Bad-Isolation!!\n");
3864 BTC_TRACE(trace_buf);
3865 } else if (psd_scan->psd_max_value >
3866 (BT_8723B_1ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
3867 + psd_scan->ant_det_thres_offset) * 100) {
3868 psd_scan->ant_det_result = 2;
3869 board_info->btdm_ant_det_finish = true;
3870 board_info->btdm_ant_det_already_init_phydm =
3871 true;
3872 board_info->btdm_ant_num_by_ant_det = 2;
3873 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3874 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Good-Isolation!!\n");
3875 BTC_TRACE(trace_buf);
3876 } else if (psd_scan->psd_max_value >
3877 (BT_8723B_1ANT_ANTDET_PSDTHRES_1ANT) *
3878 100) {
3879 psd_scan->ant_det_result = 3;
3880 board_info->btdm_ant_det_finish = true;
3881 board_info->btdm_ant_det_already_init_phydm =
3882 true;
3883 board_info->btdm_ant_num_by_ant_det = 1;
3884 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3885 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant!!\n");
3886 BTC_TRACE(trace_buf);
3887 } else {
3888 psd_scan->ant_det_result = 4;
3889 board_info->btdm_ant_det_finish = false;
3890 board_info->btdm_ant_num_by_ant_det = 1;
3891 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3892 "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant, un-certainity!!\n");
3893 BTC_TRACE(trace_buf);
3894 }
3895
3896 state = 99;
3897 break;
3898 case 99: /* restore setup */
3899
3900 /* Set AFH mask off at WiFi channel 2472MHz +/- 10MHz */
3901 h2c_parameter[0] = 0x0;
3902 h2c_parameter[1] = 0x0;
3903 h2c_parameter[2] = 0x0;
3904
3905 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3906 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d, Mask=%d\n",
3907 h2c_parameter[1], h2c_parameter[2]);
3908 BTC_TRACE(trace_buf);
3909
3910 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
3911 h2c_parameter);
3912
3913 /* Set Antenna Path */
3914 halbtc8723b1ant_set_ant_path(btcoexist,
3915 BTC_ANT_PATH_PTA, FORCE_EXEC, false,
3916 false);
3917 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3918 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to PTA\n!!");
3919 BTC_TRACE(trace_buf);
3920
3921 /* Resume Coex DM */
3922 /*
3923 btcoexist->stop_coex_dm = false;
3924 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3925 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
3926 BTC_TRACE(trace_buf); */
3927
3928 /* stimulate coex running */
3929 /*
3930 halbtc8723b1ant_run_coexist_mechanism(
3931 btcoexist);
3932 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3933 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
3934 BTC_TRACE(trace_buf);
3935 */
3936
3937 outloop = true;
3938 break;
3939 }
3940
3941 } while (!outloop);
3942
3943
3944
3945 }
3946
3947 static
3948 void halbtc8723b1ant_psd_antenna_detection_check(IN struct btc_coexist
3949 *btcoexist)
3950 {
3951 static u32 ant_det_count = 0, ant_det_fail_count = 0;
3952 struct btc_board_info *board_info = &btcoexist->board_info;
3953
3954 boolean scan, roam;
3955
3956 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3957 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3958
3959
3960 /* psd_scan->ant_det_bt_tx_time = 20; */
3961 psd_scan->ant_det_bt_tx_time =
3962 BT_8723B_1ANT_ANTDET_BTTXTIME; /* 0.42ms*50 = 20ms (0.42ms = 1 PSD sweep) */
3963 psd_scan->ant_det_bt_le_channel = BT_8723B_1ANT_ANTDET_BTTXCHANNEL;
3964
3965 ant_det_count++;
3966
3967 psd_scan->ant_det_try_count = ant_det_count;
3968
3969 if (scan || roam) {
3970 board_info->btdm_ant_det_finish = false;
3971 psd_scan->ant_det_result = 6;
3972 } else if (coex_sta->bt_disabled) {
3973 board_info->btdm_ant_det_finish = false;
3974 psd_scan->ant_det_result = 11;
3975 } else if (coex_sta->num_of_profile >= 1) {
3976 board_info->btdm_ant_det_finish = false;
3977 psd_scan->ant_det_result = 7;
3978 } else if (
3979 !psd_scan->ant_det_is_ant_det_available) { /* Antenna initial setup is not ready */
3980 board_info->btdm_ant_det_finish = false;
3981 psd_scan->ant_det_result = 9;
3982 } else if (coex_sta->c2h_bt_inquiry_page) {
3983 board_info->btdm_ant_det_finish = false;
3984 psd_scan->ant_det_result = 10;
3985 } else {
3986 btcoexist->stop_coex_dm = true;
3987
3988 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3989 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
3990 BTC_TRACE(trace_buf);
3991
3992 halbtc8723b1ant_psd_antenna_detection(btcoexist,
3993 psd_scan->ant_det_bt_tx_time,
3994 psd_scan->ant_det_bt_le_channel);
3995
3996 delay_ms(psd_scan->ant_det_bt_tx_time);
3997
3998 btcoexist->stop_coex_dm = false;
3999
4000 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4001 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
4002 BTC_TRACE(trace_buf);
4003
4004 /* stimulate coex running */
4005
4006 halbtc8723b1ant_run_coexist_mechanism(
4007 btcoexist);
4008 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4009 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
4010 BTC_TRACE(trace_buf);
4011 }
4012
4013 board_info->ant_det_result = psd_scan->ant_det_result;
4014 if (!board_info->btdm_ant_det_finish)
4015 ant_det_fail_count++;
4016
4017 psd_scan->ant_det_fail_count = ant_det_fail_count;
4018
4019 }
4020
4021
4022 /* ************************************************************
4023 * work around function start with wa_halbtc8723b1ant_
4024 * ************************************************************
4025 * ************************************************************
4026 * extern function start with ex_halbtc8723b1ant_
4027 * ************************************************************ */
4028 void ex_halbtc8723b1ant_power_on_setting(IN struct btc_coexist *btcoexist)
4029 {
4030 struct btc_board_info *board_info = &btcoexist->board_info;
4031 u8 u8tmp = 0x0;
4032 u16 u16tmp = 0x0;
4033 u32 value;
4034
4035
4036 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4037 "xxxxxxxxxxxxxxxx Execute 8723b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
4038 BTC_TRACE(trace_buf);
4039
4040 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4041 "Ant Det Finish = %s, Ant Det Number = %d\n",
4042 (board_info->btdm_ant_det_finish ? "Yes" : "No"),
4043 board_info->btdm_ant_num_by_ant_det);
4044 BTC_TRACE(trace_buf);
4045
4046
4047 btcoexist->stop_coex_dm = true;
4048
4049 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
4050
4051 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
4052 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
4053 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
4054
4055 /* set GRAN_BT = 1 */
4056 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
4057 /* set WLAN_ACT = 0 */
4058 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
4059
4060 /* */
4061 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
4062 /* Local setting bit define */
4063 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
4064 /* BIT1: "0" for internal switch; "1" for external switch */
4065 /* BIT2: "0" for one antenna; "1" for two antenna */
4066 /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
4067 if (btcoexist->chip_interface == BTC_INTF_USB) {
4068 /* fixed at S0 for USB interface */
4069 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
4070
4071 u8tmp |= 0x1; /* antenna inverse */
4072 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
4073
4074 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
4075 } else {
4076 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
4077 if (board_info->single_ant_path == 0) {
4078 /* set to S1 */
4079 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x280);
4080 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
4081 value = 1;
4082 } else if (board_info->single_ant_path == 1) {
4083 /* set to S0 */
4084 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
4085 u8tmp |= 0x1; /* antenna inverse */
4086 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
4087 value = 0;
4088 }
4089
4090 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
4091 &value);
4092
4093 if (btcoexist->chip_interface == BTC_INTF_PCI)
4094 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
4095 u8tmp);
4096 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
4097 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
4098 u8tmp);
4099 }
4100 }
4101
4102 void ex_halbtc8723b1ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
4103 {
4104 }
4105
4106 void ex_halbtc8723b1ant_init_hw_config(IN struct btc_coexist *btcoexist,
4107 IN boolean wifi_only)
4108 {
4109 halbtc8723b1ant_init_hw_config(btcoexist, true, wifi_only);
4110 btcoexist->stop_coex_dm = false;
4111 }
4112
4113 void ex_halbtc8723b1ant_init_coex_dm(IN struct btc_coexist *btcoexist)
4114 {
4115 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4116 "[BTCoex], Coex Mechanism Init!!\n");
4117 BTC_TRACE(trace_buf);
4118
4119 btcoexist->stop_coex_dm = false;
4120
4121 halbtc8723b1ant_init_coex_dm(btcoexist);
4122
4123 halbtc8723b1ant_query_bt_info(btcoexist);
4124 }
4125
4126 void ex_halbtc8723b1ant_display_coex_info(IN struct btc_coexist *btcoexist)
4127 {
4128 struct btc_board_info *board_info = &btcoexist->board_info;
4129 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4130 u8 *cli_buf = btcoexist->cli_buf;
4131 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
4132 u16 u16tmp[4];
4133 u32 u32tmp[4];
4134 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck;
4135 u32 fw_ver = 0, bt_patch_ver = 0;
4136 u32 bt_coex_ver = 0;
4137 static u8 pop_report_in_10s = 0;
4138 u32 phyver = 0;
4139
4140 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4141 "\r\n ============[BT Coexist info 8723B]============");
4142 CL_PRINTF(cli_buf);
4143
4144 if (btcoexist->manual_control) {
4145 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4146 "\r\n ============[Under Manual Control]============");
4147 CL_PRINTF(cli_buf);
4148 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4149 "\r\n ==========================================");
4150 CL_PRINTF(cli_buf);
4151 }
4152 if (btcoexist->stop_coex_dm) {
4153 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4154 "\r\n ============[Coex is STOPPED]============");
4155 CL_PRINTF(cli_buf);
4156 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4157 "\r\n ==========================================");
4158 CL_PRINTF(cli_buf);
4159 }
4160
4161 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
4162 &bt_patch_ver);
4163 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
4164
4165 if (psd_scan->ant_det_try_count == 0) {
4166 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %s/ %d",
4167 "Ant PG Num/ Mech/ Pos",
4168 board_info->pg_ant_num,
4169 (board_info->btdm_ant_num == 1 ? "Shared" : "Non-Shared"),
4170 board_info->btdm_ant_pos);
4171 CL_PRINTF(cli_buf);
4172 } else {
4173 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4174 "\r\n %-35s = %d/ %d/ %d (%d/%d/%d)",
4175 "Ant PG Num/ Mech(Ant_Det)/ Pos",
4176 board_info->pg_ant_num,
4177 board_info->btdm_ant_num_by_ant_det,
4178 board_info->btdm_ant_pos,
4179 psd_scan->ant_det_try_count,
4180 psd_scan->ant_det_fail_count,
4181 psd_scan->ant_det_result);
4182 CL_PRINTF(cli_buf);
4183
4184 if (board_info->btdm_ant_det_finish) {
4185 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4186 "Ant Det PSD Value",
4187 psd_scan->ant_det_peak_val);
4188 CL_PRINTF(cli_buf);
4189 }
4190 }
4191
4192 if (board_info->ant_det_result_five_complete) {
4193 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4194 "\r\n %-35s = %d",
4195 "Ant number by AntDet",
4196 board_info->btdm_ant_num_by_ant_det);
4197 CL_PRINTF(cli_buf);
4198 }
4199
4200 /* btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver); */
4201 bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
4202 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
4203 phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
4204 bt_coex_ver = ((coex_sta->bt_coex_supported_version & 0xff00) >> 8);
4205
4206 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4207 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
4208 "CoexVer WL/ BT_Desired/ BT_Report",
4209 glcoex_ver_date_8723b_1ant, glcoex_ver_8723b_1ant,
4210 glcoex_ver_btdesired_8723b_1ant,
4211 bt_coex_ver,
4212 (bt_coex_ver == 0xff ? "Unknown" :
4213 (bt_coex_ver >= glcoex_ver_btdesired_8723b_1ant ?
4214 "Match" : "Mis-Match")));
4215 CL_PRINTF(cli_buf);
4216
4217 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4218 "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
4219 "W_FW/ B_FW/ Phy/ Kt",
4220 fw_ver, bt_patch_ver, phyver,
4221 coex_sta->cut_version + 65);
4222 CL_PRINTF(cli_buf);
4223
4224 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
4225 "Wifi channel informed to BT",
4226 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
4227 coex_dm->wifi_chnl_info[2]);
4228 CL_PRINTF(cli_buf);
4229 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s",
4230 "WifibHiPri/ Ccklock/ CckEverLock",
4231 (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
4232 (coex_sta->cck_lock ? "Yes" : "No"),
4233 (coex_sta->cck_ever_lock ? "Yes" : "No"));
4234 CL_PRINTF(cli_buf);
4235
4236 /* wifi status */
4237 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4238 "============[Wifi Status]============");
4239 CL_PRINTF(cli_buf);
4240 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
4241
4242 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4243 "============[BT Status]============");
4244 CL_PRINTF(cli_buf);
4245
4246 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4247 "BT Abnormal scan",
4248 (coex_sta->bt_abnormal_scan) ? "Yes" : "No");
4249 CL_PRINTF(cli_buf);
4250
4251 pop_report_in_10s++;
4252 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s/ %d/ %d/ %d] ",
4253 "BT [status/ rssi/ retryCnt/ popCnt]",
4254 ((coex_sta->bt_disabled) ? ("disabled") : ((
4255 coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan")
4256 : ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
4257 coex_dm->bt_status) ? "non-connected idle" :
4258 ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
4259 ? "connected-idle" : "busy")))),
4260 coex_sta->bt_rssi, coex_sta->bt_retry_cnt,
4261 coex_sta->pop_event_cnt);
4262 CL_PRINTF(cli_buf);
4263
4264 if (pop_report_in_10s >= 5) {
4265 coex_sta->pop_event_cnt = 0;
4266 pop_report_in_10s = 0;
4267 }
4268
4269 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4270 "\r\n %-35s = %d / %d / %d / %d / %d / %d",
4271 "SCO/HID/PAN/A2DP/NameReq/WHQL",
4272 bt_link_info->sco_exist, bt_link_info->hid_exist,
4273 bt_link_info->pan_exist, bt_link_info->a2dp_exist,
4274 coex_sta->c2h_bt_remote_name_req,
4275 coex_sta->bt_whck_test);
4276 CL_PRINTF(cli_buf);
4277
4278 if (bt_link_info->hid_exist) {
4279 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "HID ratio info",
4280 (coex_sta->hid_busy_num >= 2) ? "HID(4/18)" : "HID(2/18)");
4281 CL_PRINTF(cli_buf);
4282 }
4283
4284 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4285 "BT Role",
4286 (bt_link_info->slave_role) ? "Slave" : "Master");
4287 CL_PRINTF(cli_buf);
4288
4289 bt_info_ext = coex_sta->bt_info_ext;
4290 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d",
4291 "A2DP Rate/Bitpool",
4292 (bt_info_ext & BIT(0)) ? "BR" : "EDR", coex_sta->a2dp_bit_pool);
4293 CL_PRINTF(cli_buf);
4294
4295 for (i = 0; i < BT_INFO_SRC_8723B_1ANT_MAX; i++) {
4296 if (coex_sta->bt_info_c2h_cnt[i]) {
4297 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4298 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)",
4299 glbt_info_src_8723b_1ant[i],
4300 coex_sta->bt_info_c2h[i][0],
4301 coex_sta->bt_info_c2h[i][1],
4302 coex_sta->bt_info_c2h[i][2],
4303 coex_sta->bt_info_c2h[i][3],
4304 coex_sta->bt_info_c2h[i][4],
4305 coex_sta->bt_info_c2h[i][5],
4306 coex_sta->bt_info_c2h[i][6],
4307 coex_sta->bt_info_c2h_cnt[i]);
4308 CL_PRINTF(cli_buf);
4309 }
4310 }
4311
4312
4313 if (btcoexist->manual_control)
4314 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4315 "============[mechanisms] (before Manual)============");
4316 else
4317 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4318 "============[mechanisms]============");
4319 CL_PRINTF(cli_buf);
4320
4321 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4322 "SM[LowPenaltyRA]",
4323 coex_dm->cur_low_penalty_ra);
4324 CL_PRINTF(cli_buf);
4325
4326 ps_tdma_case = coex_dm->cur_ps_tdma;
4327 if (board_info->btdm_ant_num_by_ant_det == 2) {
4328 if (coex_dm->cur_ps_tdma_on)
4329 ps_tdma_case = ps_tdma_case +
4330 100; /* for WiFi RSSI low or BT RSSI low */
4331 else
4332 ps_tdma_case =
4333 1; /* always translate to TDMA(off,1) for TDMA-off case */
4334 }
4335 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4336 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (%s,%s)",
4337 "PS TDMA",
4338 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
4339 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
4340 coex_dm->ps_tdma_para[4], ps_tdma_case,
4341 (coex_dm->cur_ps_tdma_on ? "On" : "Off"),
4342 (coex_dm->auto_tdma_adjust ? "Adj" : "Fix"));
4343
4344 CL_PRINTF(cli_buf);
4345
4346 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4347 "Coex Table Type",
4348 coex_sta->coex_table_type);
4349 CL_PRINTF(cli_buf);
4350
4351 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4352 "IgnWlanAct",
4353 coex_dm->cur_ignore_wlan_act);
4354 CL_PRINTF(cli_buf);
4355
4356 /*
4357 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x ", "Latest error condition(should be 0)",
4358 coex_dm->error_condition);
4359 CL_PRINTF(cli_buf);
4360 */
4361
4362 /* Hw setting */
4363 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4364 "============[Hw setting]============");
4365 CL_PRINTF(cli_buf);
4366
4367 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
4368 "backup ARFR1/ARFR2/RL/AMaxTime",
4369 coex_dm->backup_arfr_cnt1, coex_dm->backup_arfr_cnt2,
4370 coex_dm->backup_retry_limit,
4371 coex_dm->backup_ampdu_max_time);
4372 CL_PRINTF(cli_buf);
4373
4374 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
4375 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
4376 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
4377 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
4378 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
4379 "0x430/0x434/0x42a/0x456",
4380 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
4381 CL_PRINTF(cli_buf);
4382
4383 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
4384 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
4385 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x880);
4386 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
4387 "0x778/0x6cc/0x880[29:25]",
4388 u8tmp[0], u32tmp[0], (u32tmp[1] & 0x3e000000) >> 25);
4389 CL_PRINTF(cli_buf);
4390
4391 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
4392 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
4393 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x764);
4394 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x76e);
4395 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4396 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4397 "0x948/ 0x67[5] / 0x764 / 0x76e",
4398 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), (u32tmp[1] & 0xffff),
4399 u8tmp[1]);
4400 CL_PRINTF(cli_buf);
4401
4402 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
4403 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
4404 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
4405 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
4406 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
4407 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
4408 CL_PRINTF(cli_buf);
4409
4410 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
4411 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
4412 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
4413 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
4414 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4415 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4416 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
4417 ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
4418 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
4419 CL_PRINTF(cli_buf);
4420
4421 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
4422 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
4423 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4424 "0x550(bcn ctrl)/0x522",
4425 u32tmp[0], u8tmp[0]);
4426 CL_PRINTF(cli_buf);
4427
4428 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
4429 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
4430 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4431 "0xc50(dig)/0x49c(null-drop)",
4432 u32tmp[0] & 0xff, u8tmp[0]);
4433 CL_PRINTF(cli_buf);
4434
4435 fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4436 PHYDM_INFO_FA_OFDM);
4437 fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4438 PHYDM_INFO_FA_CCK);
4439 cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4440 PHYDM_INFO_CCA_OFDM);
4441 cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist,
4442 PHYDM_INFO_CCA_CCK);
4443
4444 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4445 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4446 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
4447 cca_cck, fa_cck, cca_ofdm, fa_ofdm);
4448 CL_PRINTF(cli_buf);
4449
4450 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4451 "CRC_OK CCK/11g/11n/11n-agg",
4452 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
4453 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
4454 CL_PRINTF(cli_buf);
4455
4456 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4457 "CRC_Err CCK/11g/11n/11n-agg",
4458 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
4459 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
4460 CL_PRINTF(cli_buf);
4461
4462 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
4463 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
4464 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
4465 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
4466 "0x6c0/0x6c4/0x6c8(coexTable)",
4467 u32tmp[0], u32tmp[1], u32tmp[2]);
4468 CL_PRINTF(cli_buf);
4469
4470 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4471 "0x770(high-pri rx/tx)",
4472 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
4473 CL_PRINTF(cli_buf);
4474 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4475 "0x774(low-pri rx/tx)",
4476 coex_sta->low_priority_rx, coex_sta->low_priority_tx);
4477 CL_PRINTF(cli_buf);
4478 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 1)
4479 /* halbtc8723b1ant_monitor_bt_ctr(btcoexist); */
4480 #endif
4481 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
4482 }
4483
4484
4485 void ex_halbtc8723b1ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
4486 {
4487 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4488 return;
4489
4490 if (BTC_IPS_ENTER == type) {
4491 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4492 "[BTCoex], IPS ENTER notify\n");
4493 BTC_TRACE(trace_buf);
4494 coex_sta->under_ips = true;
4495
4496 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
4497 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
4498 FORCE_EXEC, false, true);
4499 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
4500 } else if (BTC_IPS_LEAVE == type) {
4501 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4502 "[BTCoex], IPS LEAVE notify\n");
4503 BTC_TRACE(trace_buf);
4504
4505 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
4506 halbtc8723b1ant_init_coex_dm(btcoexist);
4507 halbtc8723b1ant_query_bt_info(btcoexist);
4508
4509 coex_sta->under_ips = false;
4510 }
4511 }
4512
4513 void ex_halbtc8723b1ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
4514 {
4515 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4516 return;
4517
4518 if (BTC_LPS_ENABLE == type) {
4519 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4520 "[BTCoex], LPS ENABLE notify\n");
4521 BTC_TRACE(trace_buf);
4522 coex_sta->under_lps = true;
4523 } else if (BTC_LPS_DISABLE == type) {
4524 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4525 "[BTCoex], LPS DISABLE notify\n");
4526 BTC_TRACE(trace_buf);
4527 coex_sta->under_lps = false;
4528 }
4529 }
4530
4531 void ex_halbtc8723b1ant_scan_notify(IN struct btc_coexist *btcoexist,
4532 IN u8 type)
4533 {
4534 boolean wifi_connected = false, bt_hs_on = false;
4535 u32 wifi_link_status = 0;
4536 u32 num_of_wifi_link = 0;
4537 boolean bt_ctrl_agg_buf_size = false;
4538 u8 agg_buf_size = 5;
4539
4540 u8 u8tmpa, u8tmpb;
4541 u32 u32tmp;
4542
4543 if (btcoexist->manual_control ||
4544 btcoexist->stop_coex_dm)
4545 return;
4546
4547 if (BTC_SCAN_START == type) {
4548 coex_sta->wifi_is_high_pri_task = true;
4549 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4550 "[BTCoex], SCAN START notify\n");
4551 BTC_TRACE(trace_buf);
4552 psd_scan->ant_det_is_ant_det_available = true;
4553 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
4554 8); /* Force antenna setup for no scan result issue */
4555 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
4556 FORCE_EXEC, false, false);
4557 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
4558 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
4559 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
4560
4561
4562 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4563 "[BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n",
4564 u32tmp, u8tmpa, u8tmpb);
4565 BTC_TRACE(trace_buf);
4566 } else {
4567 coex_sta->wifi_is_high_pri_task = false;
4568 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4569 "[BTCoex], SCAN FINISH notify\n");
4570 BTC_TRACE(trace_buf);
4571
4572 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
4573 &coex_sta->scan_ap_num);
4574 }
4575
4576 if (coex_sta->bt_disabled)
4577 return;
4578
4579 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
4580 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4581 &wifi_connected);
4582
4583 halbtc8723b1ant_query_bt_info(btcoexist);
4584
4585 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
4586 &wifi_link_status);
4587 num_of_wifi_link = wifi_link_status >> 16;
4588 if (num_of_wifi_link >= 2) {
4589 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
4590 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
4591 bt_ctrl_agg_buf_size, agg_buf_size);
4592 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
4593 return;
4594 }
4595
4596 if (coex_sta->c2h_bt_inquiry_page) {
4597 halbtc8723b1ant_action_bt_inquiry(btcoexist);
4598 return;
4599 } else if (bt_hs_on) {
4600 halbtc8723b1ant_action_hs(btcoexist);
4601 return;
4602 }
4603
4604 if (BTC_SCAN_START == type) {
4605 if (!wifi_connected) /* non-connected scan */
4606 halbtc8723b1ant_action_wifi_not_connected_scan(
4607 btcoexist);
4608 else /* wifi is connected */
4609 halbtc8723b1ant_action_wifi_connected_scan(btcoexist);
4610 } else if (BTC_SCAN_FINISH == type) {
4611 if (!wifi_connected) /* non-connected scan */
4612 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
4613 else
4614 halbtc8723b1ant_action_wifi_connected(btcoexist);
4615 }
4616 }
4617
4618 void ex_halbtc8723b1ant_set_antenna_notify(IN struct btc_coexist *btcoexist,
4619 IN u8 type)
4620 {
4621 struct btc_board_info *board_info = &btcoexist->board_info;
4622
4623 if (btcoexist->manual_control || btcoexist->stop_coex_dm)
4624 return;
4625
4626 if (type == 2) /* two antenna */
4627 halbtc8723b1ant_mechanism_switch(btcoexist, true);
4628 else /* one antenna */
4629 halbtc8723b1ant_mechanism_switch(btcoexist, false);
4630 }
4631
4632 void ex_halbtc8723b1ant_connect_notify(IN struct btc_coexist *btcoexist,
4633 IN u8 type)
4634 {
4635 boolean wifi_connected = false, bt_hs_on = false;
4636 u32 wifi_link_status = 0;
4637 u32 num_of_wifi_link = 0;
4638 boolean bt_ctrl_agg_buf_size = false;
4639 u8 agg_buf_size = 5;
4640
4641 if (btcoexist->manual_control ||
4642 btcoexist->stop_coex_dm)
4643 return;
4644
4645 if (BTC_ASSOCIATE_START == type) {
4646 coex_sta->wifi_is_high_pri_task = true;
4647 psd_scan->ant_det_is_ant_det_available = true;
4648 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
4649 8); /* Force antenna setup for no scan result issue */
4650 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
4651 FORCE_EXEC, false, false);
4652 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4653 "[BTCoex], CONNECT START notify\n");
4654 BTC_TRACE(trace_buf);
4655 coex_dm->arp_cnt = 0;
4656 coex_sta->connect_ap_period_cnt = 2;
4657 } else {
4658 coex_sta->wifi_is_high_pri_task = false;
4659 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4660 "[BTCoex], CONNECT FINISH notify\n");
4661 BTC_TRACE(trace_buf);
4662 /* coex_dm->arp_cnt = 0; */
4663 }
4664
4665 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
4666 &wifi_link_status);
4667 num_of_wifi_link = wifi_link_status >> 16;
4668 if (num_of_wifi_link >= 2) {
4669 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
4670 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
4671 bt_ctrl_agg_buf_size, agg_buf_size);
4672 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
4673 return;
4674 }
4675
4676 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
4677 if (coex_sta->c2h_bt_inquiry_page) {
4678 halbtc8723b1ant_action_bt_inquiry(btcoexist);
4679 return;
4680 } else if (bt_hs_on) {
4681 halbtc8723b1ant_action_hs(btcoexist);
4682 return;
4683 }
4684
4685 if (BTC_ASSOCIATE_START == type)
4686 halbtc8723b1ant_action_wifi_not_connected_asso_auth(btcoexist);
4687 else if (BTC_ASSOCIATE_FINISH == type) {
4688 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4689 &wifi_connected);
4690 if (!wifi_connected) /* non-connected scan */
4691 halbtc8723b1ant_action_wifi_not_connected(btcoexist);
4692 else
4693 halbtc8723b1ant_action_wifi_connected(btcoexist);
4694 }
4695 }
4696
4697 void ex_halbtc8723b1ant_media_status_notify(IN struct btc_coexist *btcoexist,
4698 IN u8 type)
4699 {
4700 u8 h2c_parameter[3] = {0};
4701 u32 wifi_bw;
4702 u8 wifi_central_chnl;
4703 boolean wifi_under_b_mode = false;
4704
4705 if (btcoexist->manual_control ||
4706 btcoexist->stop_coex_dm)
4707 return;
4708
4709 if (BTC_MEDIA_CONNECT == type) {
4710 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4711 "[BTCoex], MEDIA connect notify\n");
4712 BTC_TRACE(trace_buf);
4713 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false,
4714 8); /* Force antenna setup for no scan result issue */
4715 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
4716 FORCE_EXEC, false, false);
4717 psd_scan->ant_det_is_ant_det_available = true;
4718 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
4719 &wifi_under_b_mode);
4720
4721 /* Set CCK Tx/Rx high Pri except 11b mode */
4722 if (wifi_under_b_mode) {
4723 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4724 0x00); /* CCK Tx */
4725 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4726 0x00); /* CCK Rx */
4727 } else {
4728 btcoexist->btc_write_1byte(btcoexist, 0x6cd,
4729 0x00); /* CCK Tx */
4730 btcoexist->btc_write_1byte(btcoexist, 0x6cf,
4731 0x10); /* CCK Rx */
4732 }
4733
4734 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
4735 0x430);
4736 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
4737 0x434);
4738 coex_dm->backup_retry_limit = btcoexist->btc_read_2byte(
4739 btcoexist, 0x42a);
4740 coex_dm->backup_ampdu_max_time = btcoexist->btc_read_1byte(
4741 btcoexist, 0x456);
4742 } else {
4743 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4744 "[BTCoex], MEDIA disconnect notify\n");
4745 BTC_TRACE(trace_buf);
4746 coex_dm->arp_cnt = 0;
4747
4748 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
4749 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
4750
4751 coex_sta->cck_ever_lock = false;
4752 }
4753
4754 /* only 2.4G we need to inform bt the chnl mask */
4755 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
4756 &wifi_central_chnl);
4757 if ((BTC_MEDIA_CONNECT == type) &&
4758 (wifi_central_chnl <= 14)) {
4759 /* h2c_parameter[0] = 0x1; */
4760 h2c_parameter[0] = 0x0;
4761 h2c_parameter[1] = wifi_central_chnl;
4762 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
4763 if (BTC_WIFI_BW_HT40 == wifi_bw)
4764 h2c_parameter[2] = 0x30;
4765 else
4766 h2c_parameter[2] = 0x20;
4767 }
4768
4769 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
4770 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
4771 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
4772
4773 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
4774 }
4775
4776 void ex_halbtc8723b1ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
4777 IN u8 type)
4778 {
4779 boolean bt_hs_on = false;
4780 u32 wifi_link_status = 0;
4781 u32 num_of_wifi_link = 0;
4782 boolean bt_ctrl_agg_buf_size = false, under_4way = false;
4783 u8 agg_buf_size = 5;
4784
4785 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
4786 &under_4way);
4787
4788 if (btcoexist->manual_control ||
4789 btcoexist->stop_coex_dm)
4790 return;
4791
4792 if (BTC_PACKET_DHCP == type ||
4793 BTC_PACKET_EAPOL == type ||
4794 BTC_PACKET_ARP == type) {
4795 if (BTC_PACKET_ARP == type) {
4796 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4797 "[BTCoex], specific Packet ARP notify\n");
4798 BTC_TRACE(trace_buf);
4799
4800 coex_dm->arp_cnt++;
4801 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4802 "[BTCoex], ARP Packet Count = %d\n",
4803 coex_dm->arp_cnt);
4804 BTC_TRACE(trace_buf);
4805
4806 if ((coex_dm->arp_cnt >= 10) &&
4807 (!under_4way)) /* if APR PKT > 10 after connect, do not go to ActionWifiConnectedSpecificPacket(btcoexist) */
4808 coex_sta->wifi_is_high_pri_task = false;
4809 else
4810 coex_sta->wifi_is_high_pri_task = true;
4811 } else {
4812 coex_sta->wifi_is_high_pri_task = true;
4813 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4814 "[BTCoex], specific Packet DHCP or EAPOL notify\n");
4815 BTC_TRACE(trace_buf);
4816 }
4817 } else {
4818 coex_sta->wifi_is_high_pri_task = false;
4819 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4820 "[BTCoex], specific Packet [Type = %d] notify\n", type);
4821 BTC_TRACE(trace_buf);
4822 }
4823
4824 coex_sta->specific_pkt_period_cnt = 0;
4825
4826 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
4827 &wifi_link_status);
4828 num_of_wifi_link = wifi_link_status >> 16;
4829 if (num_of_wifi_link >= 2) {
4830 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
4831 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
4832 bt_ctrl_agg_buf_size, agg_buf_size);
4833 halbtc8723b1ant_action_wifi_multi_port(btcoexist);
4834 return;
4835 }
4836
4837 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
4838 if (coex_sta->c2h_bt_inquiry_page) {
4839 halbtc8723b1ant_action_bt_inquiry(btcoexist);
4840 return;
4841 } else if (bt_hs_on) {
4842 halbtc8723b1ant_action_hs(btcoexist);
4843 return;
4844 }
4845
4846 if (BTC_PACKET_DHCP == type ||
4847 BTC_PACKET_EAPOL == type ||
4848 ((BTC_PACKET_ARP == type) && (coex_sta->wifi_is_high_pri_task)))
4849 halbtc8723b1ant_action_wifi_connected_specific_packet(
4850 btcoexist);
4851 }
4852
4853 /* Donot remove optimize off flag, otherwise antenna detection would trigger BT collapsed */
4854 #ifdef PLATFORM_WINDOWS
4855 #pragma optimize("", off)
4856 #endif
4857 void ex_halbtc8723b1ant_bt_info_notify(IN struct btc_coexist *btcoexist,
4858 IN u8 *tmp_buf, IN u8 length)
4859 {
4860 u8 bt_info = 0;
4861 u8 i, rsp_source = 0;
4862 boolean wifi_connected = false;
4863 boolean bt_busy = false;
4864 struct btc_board_info *board_info = &btcoexist->board_info;
4865
4866 coex_sta->c2h_bt_info_req_sent = false;
4867
4868 rsp_source = tmp_buf[0] & 0xf;
4869 if (rsp_source >= BT_INFO_SRC_8723B_1ANT_MAX)
4870 rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
4871 coex_sta->bt_info_c2h_cnt[rsp_source]++;
4872
4873 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4874 "[BTCoex], Bt info[%d], length=%d, hex data=[", rsp_source,
4875 length);
4876 BTC_TRACE(trace_buf);
4877 for (i = 0; i < length; i++) {
4878 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
4879 if (i == 1)
4880 bt_info = tmp_buf[i];
4881 if (i == length - 1) {
4882 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
4883 tmp_buf[i]);
4884 BTC_TRACE(trace_buf);
4885 } else {
4886 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
4887 tmp_buf[i]);
4888 BTC_TRACE(trace_buf);
4889 }
4890 }
4891
4892 /* if 0xff, it means BT is under WHCK test */
4893 if (bt_info == 0xff)
4894 coex_sta->bt_whck_test = true;
4895 else
4896 coex_sta->bt_whck_test = false;
4897
4898 if (BT_INFO_SRC_8723B_1ANT_WIFI_FW != rsp_source) {
4899 coex_sta->bt_retry_cnt = /* [3:0] */
4900 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4901
4902 if (coex_sta->bt_retry_cnt >= 1)
4903 coex_sta->pop_event_cnt++;
4904
4905 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
4906 coex_sta->c2h_bt_remote_name_req = true;
4907 else
4908 coex_sta->c2h_bt_remote_name_req = false;
4909
4910 coex_sta->bt_rssi =
4911 coex_sta->bt_info_c2h[rsp_source][3] * 2 - 90;
4912 /* coex_sta->bt_info_c2h[rsp_source][3]*2+10; */
4913
4914 coex_sta->bt_info_ext =
4915 coex_sta->bt_info_c2h[rsp_source][4];
4916
4917 if ((coex_sta->bt_info_c2h[rsp_source][1] & 0x49) == 0x49) {
4918 coex_sta->a2dp_bit_pool =
4919 coex_sta->bt_info_c2h[rsp_source][6] & 0x7f;
4920 } else
4921 coex_sta->a2dp_bit_pool = 0;
4922
4923 coex_sta->bt_tx_rx_mask = (coex_sta->bt_info_c2h[rsp_source][2]
4924 & 0x40);
4925 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
4926 &coex_sta->bt_tx_rx_mask);
4927
4928 if (btcoexist->stop_coex_dm) {
4929 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4930 "############# [BTCoex], BT info Notify() return because stop_coex_dm\n");
4931 BTC_TRACE(trace_buf);
4932
4933 return;
4934 }
4935
4936 coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
4937 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
4938
4939 #if BT_8723B_1ANT_ANTDET_ENABLE
4940 #if BT_8723B_1ANT_ANTDET_COEXMECHANISMSWITCH_ENABLE
4941 if ((board_info->btdm_ant_det_finish) &&
4942 (board_info->btdm_ant_num_by_ant_det == 2)) {
4943 if (coex_sta->bt_tx_rx_mask) {
4944
4945 /* BT TRx mask off */
4946 btcoexist->btc_set_bt_trx_mask(btcoexist, 0);
4947
4948 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4949 "############# [BTCoex], BT TRx Mask off for BT Info Notify\n");
4950 BTC_TRACE(trace_buf);
4951 #if 0
4952 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
4953 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4954 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x1\n");
4955 BTC_TRACE(trace_buf);
4956
4957 /* BT TRx Mask un-lock 0x2c[0], 0x30[0] = 1 */
4958 btcoexist->btc_set_bt_reg(btcoexist,
4959 BTC_BT_REG_RF, 0x2c, 0x7c45);
4960 btcoexist->btc_set_bt_reg(btcoexist,
4961 BTC_BT_REG_RF, 0x30, 0x7c45);
4962
4963 btcoexist->btc_set_bt_reg(btcoexist,
4964 BTC_BT_REG_RF, 0x3c, 0x1);
4965 #endif
4966 }
4967 } else
4968 #endif
4969 #endif
4970
4971 {
4972 if (!coex_sta->bt_tx_rx_mask) {
4973
4974 /* BT TRx mask on */
4975 btcoexist->btc_set_bt_trx_mask(btcoexist, 1);
4976
4977 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4978 "############# [BTCoex], BT TRx Mask on for BT Info Notify\n");
4979 BTC_TRACE(trace_buf);
4980 #if 0
4981 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
4982 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4983 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
4984 BTC_TRACE(trace_buf);
4985 btcoexist->btc_set_bt_reg(btcoexist,
4986 BTC_BT_REG_RF,
4987 0x3c, 0x15);
4988
4989 /* BT TRx Mask lock 0x2c[0], 0x30[0] = 0 */
4990 btcoexist->btc_set_bt_reg(btcoexist,
4991 BTC_BT_REG_RF,
4992 0x2c, 0x7c44);
4993 btcoexist->btc_set_bt_reg(btcoexist,
4994 BTC_BT_REG_RF,
4995 0x30, 0x7c44);
4996 #endif
4997 }
4998 }
4999
5000 /* Here we need to resend some wifi info to BT */
5001 /* because bt is reset and loss of the info. */
5002 if (coex_sta->bt_info_ext & BIT(1)) {
5003 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5004 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
5005 BTC_TRACE(trace_buf);
5006 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
5007 &wifi_connected);
5008 if (wifi_connected)
5009 ex_halbtc8723b1ant_media_status_notify(
5010 btcoexist, BTC_MEDIA_CONNECT);
5011 else
5012 ex_halbtc8723b1ant_media_status_notify(
5013 btcoexist, BTC_MEDIA_DISCONNECT);
5014 }
5015
5016 if (coex_sta->bt_info_ext & BIT(3)) {
5017 if (!btcoexist->manual_control &&
5018 !btcoexist->stop_coex_dm) {
5019 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5020 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
5021 BTC_TRACE(trace_buf);
5022 halbtc8723b1ant_ignore_wlan_act(btcoexist,
5023 FORCE_EXEC, false);
5024 }
5025 } else {
5026 /* BT already NOT ignore Wlan active, do nothing here. */
5027 }
5028 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
5029 if ((coex_sta->bt_info_ext & BIT(4))) {
5030 /* BT auto report already enabled, do nothing */
5031 } else
5032 halbtc8723b1ant_bt_auto_report(btcoexist, FORCE_EXEC,
5033 true);
5034 #endif
5035 }
5036
5037 /* check BIT2 first ==> check if bt is under inquiry or page scan */
5038 if (bt_info & BT_INFO_8723B_1ANT_B_INQ_PAGE)
5039 coex_sta->c2h_bt_inquiry_page = true;
5040 else
5041 coex_sta->c2h_bt_inquiry_page = false;
5042
5043 coex_sta->num_of_profile = 0;
5044
5045 /* set link exist status */
5046 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) {
5047 coex_sta->bt_link_exist = false;
5048 coex_sta->pan_exist = false;
5049 coex_sta->a2dp_exist = false;
5050 coex_sta->hid_exist = false;
5051 coex_sta->sco_exist = false;
5052
5053 coex_sta->bt_hi_pri_link_exist = false;
5054 } else { /* connection exists */
5055 coex_sta->bt_link_exist = true;
5056 if (bt_info & BT_INFO_8723B_1ANT_B_FTP) {
5057 coex_sta->pan_exist = true;
5058 coex_sta->num_of_profile++;
5059 } else
5060 coex_sta->pan_exist = false;
5061 if (bt_info & BT_INFO_8723B_1ANT_B_A2DP) {
5062 coex_sta->a2dp_exist = true;
5063 coex_sta->num_of_profile++;
5064 } else
5065 coex_sta->a2dp_exist = false;
5066 if (bt_info & BT_INFO_8723B_1ANT_B_HID) {
5067 coex_sta->hid_exist = true;
5068 coex_sta->num_of_profile++;
5069 } else
5070 coex_sta->hid_exist = false;
5071 if (bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) {
5072 coex_sta->sco_exist = true;
5073 coex_sta->num_of_profile++;
5074 } else
5075 coex_sta->sco_exist = false;
5076
5077 if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) &&
5078 (coex_sta->hid_exist == true)) {
5079 coex_sta->hid_exist = false;
5080 coex_sta->num_of_profile--;
5081 }
5082 if ((coex_sta->hid_exist == false) &&
5083 (coex_sta->c2h_bt_inquiry_page == false) &&
5084 (coex_sta->sco_exist == false)) {
5085 if (coex_sta->high_priority_tx +
5086 coex_sta->high_priority_rx >= 160) {
5087 coex_sta->hid_exist = true;
5088 coex_sta->wrong_profile_notification++;
5089 coex_sta->num_of_profile++;
5090 bt_info = bt_info | 0x28;
5091 }
5092 }
5093
5094 /* Add Hi-Pri Tx/Rx counter to avoid false detection */
5095 if (((coex_sta->hid_exist) || (coex_sta->sco_exist)) &&
5096 (coex_sta->high_priority_tx +
5097 coex_sta->high_priority_rx >= 160)
5098 && (!coex_sta->c2h_bt_inquiry_page))
5099 coex_sta->bt_hi_pri_link_exist = true;
5100
5101 if ((bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) &&
5102 (coex_sta->num_of_profile == 0)) {
5103 if (coex_sta->low_priority_tx +
5104 coex_sta->low_priority_rx >= 160) {
5105 coex_sta->pan_exist = true;
5106 coex_sta->num_of_profile++;
5107 coex_sta->wrong_profile_notification++;
5108 bt_info = bt_info | 0x88;
5109 }
5110 }
5111 }
5112
5113 halbtc8723b1ant_update_bt_link_info(btcoexist);
5114
5115 bt_info = bt_info &
5116 0x1f; /* mask profile bit for connect-ilde identification ( for CSR case: A2DP idle --> 0x41) */
5117
5118 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION))
5119 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
5120 else if (bt_info ==
5121 BT_INFO_8723B_1ANT_B_CONNECTION) /* connection exists but no busy */
5122 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
5123 else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
5124 (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY))
5125 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
5126 else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
5127 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
5128 coex_dm->auto_tdma_adjust = false;
5129 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
5130 } else
5131 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_MAX;
5132
5133 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
5134 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
5135 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
5136 bt_busy = true;
5137 else
5138 bt_busy = false;
5139 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
5140
5141 halbtc8723b1ant_run_coexist_mechanism(btcoexist);
5142 }
5143
5144 void ex_halbtc8723b1ant_rf_status_notify(IN struct btc_coexist *btcoexist,
5145 IN u8 type)
5146 {
5147 u32 u32tmp;
5148 u8 u8tmpa, u8tmpb, u8tmpc;
5149
5150 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
5151 BTC_TRACE(trace_buf);
5152
5153 if (BTC_RF_ON == type) {
5154 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5155 "[BTCoex], RF is turned ON!!\n");
5156 BTC_TRACE(trace_buf);
5157 btcoexist->stop_coex_dm = false;
5158 } else if (BTC_RF_OFF == type) {
5159 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5160 "[BTCoex], RF is turned OFF!!\n");
5161 BTC_TRACE(trace_buf);
5162
5163 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
5164 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
5165 FORCE_EXEC, false, true);
5166
5167 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
5168 btcoexist->stop_coex_dm = true;
5169
5170 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
5171 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
5172 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67);
5173 u8tmpc = btcoexist->btc_read_1byte(btcoexist, 0x76e);
5174
5175
5176 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5177 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x, 0x76e=0x%x\n",
5178 u32tmp, u8tmpa, u8tmpb, u8tmpc);
5179 BTC_TRACE(trace_buf);
5180
5181 }
5182 }
5183
5184 void ex_halbtc8723b1ant_halt_notify(IN struct btc_coexist *btcoexist)
5185 {
5186 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
5187 BTC_TRACE(trace_buf);
5188
5189 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
5190 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, FORCE_EXEC,
5191 false, true);
5192
5193 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
5194
5195 ex_halbtc8723b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
5196
5197 btcoexist->stop_coex_dm = true;
5198 }
5199
5200 void ex_halbtc8723b1ant_pnp_notify(IN struct btc_coexist *btcoexist,
5201 IN u8 pnp_state)
5202 {
5203 if ((pnp_state == BTC_WIFI_PNP_SLEEP) || (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT)) {
5204 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5205 "[BTCoex], Pnp notify to SLEEP\n");
5206 BTC_TRACE(trace_buf);
5207
5208 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
5209
5210 if (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT)
5211 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
5212 FORCE_EXEC, false, false);
5213 else
5214 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
5215 FORCE_EXEC, false, true);
5216
5217 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
5218
5219 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
5220 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
5221 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
5222 coex_sta->under_ips = false;
5223 coex_sta->under_lps = false;
5224 btcoexist->stop_coex_dm = true;
5225 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
5226 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5227 "[BTCoex], Pnp notify to WAKE UP\n");
5228 BTC_TRACE(trace_buf);
5229 btcoexist->stop_coex_dm = false;
5230 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
5231 halbtc8723b1ant_init_coex_dm(btcoexist);
5232 halbtc8723b1ant_query_bt_info(btcoexist);
5233 }
5234 }
5235
5236 void ex_halbtc8723b1ant_coex_dm_reset(IN struct btc_coexist *btcoexist)
5237 {
5238
5239 halbtc8723b1ant_init_hw_config(btcoexist, false, false);
5240 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
5241 /* btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x2, 0xfffff, 0x0); */
5242 halbtc8723b1ant_init_coex_dm(btcoexist);
5243 }
5244
5245 void ex_halbtc8723b1ant_periodical(IN struct btc_coexist *btcoexist)
5246 {
5247 u32 bt_patch_ver;
5248
5249 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5250 "[BTCoex], ==========================Periodical===========================\n");
5251 BTC_TRACE(trace_buf);
5252
5253 #if (BT_AUTO_REPORT_ONLY_8723B_1ANT == 0)
5254 halbtc8723b1ant_query_bt_info(btcoexist);
5255 #endif
5256 halbtc8723b1ant_monitor_bt_ctr(btcoexist);
5257 halbtc8723b1ant_monitor_wifi_ctr(btcoexist);
5258
5259 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist);
5260
5261
5262 if (halbtc8723b1ant_is_wifi_status_changed(btcoexist) ||
5263 coex_dm->auto_tdma_adjust ||
5264 btcoexist->bt_info.bt_enable_disable_change)
5265 halbtc8723b1ant_run_coexist_mechanism(btcoexist);
5266
5267 if (((coex_sta->bt_coex_supported_version == 0) ||
5268 (coex_sta->bt_coex_supported_version == 0xffff)) && (!coex_sta->bt_disabled))
5269 btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION, &coex_sta->bt_coex_supported_version);
5270
5271 /*btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);*/
5272 /*btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;*/
5273 coex_sta->specific_pkt_period_cnt++;
5274
5275 /*for A2DP glitch during connecting AP*/
5276 if (coex_sta->connect_ap_period_cnt > 0)
5277 coex_sta->connect_ap_period_cnt--;
5278
5279 /* sample to set bt to execute Ant detection */
5280 /* btcoexist->btc_set_bt_ant_detection(btcoexist, 20, 14);
5281 *
5282 if (psd_scan->is_ant_det_enable)
5283 {
5284 if (psd_scan->psd_gen_count > psd_scan->realseconds)
5285 psd_scan->psd_gen_count = 0;
5286
5287 halbtc8723b1ant_antenna_detection(btcoexist, psd_scan->realcent_freq, psd_scan->realoffset, psd_scan->realspan, psd_scan->realseconds);
5288 psd_scan->psd_gen_total_count +=2;
5289 psd_scan->psd_gen_count += 2;
5290 }
5291 */
5292 }
5293
5294 /* Donot remove optimize off flag, otherwise antenna detection would trigger BT collapsed */
5295 #ifdef PLATFORM_WINDOWS
5296 #pragma optimize("", off)
5297 #endif
5298 void ex_halbtc8723b1ant_antenna_detection(IN struct btc_coexist *btcoexist,
5299 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
5300 {
5301 #if BT_8723B_1ANT_ANTDET_ENABLE
5302 static u32 ant_det_count = 0, ant_det_fail_count = 0;
5303 struct btc_board_info *board_info = &btcoexist->board_info;
5304 /*boolean scan, roam;*/
5305
5306 if (seconds == 0) {
5307 psd_scan->ant_det_try_count = 0;
5308 psd_scan->ant_det_fail_count = 0;
5309 ant_det_count = 0;
5310 ant_det_fail_count = 0;
5311 board_info->btdm_ant_det_finish = false;
5312 board_info->btdm_ant_num_by_ant_det = 1;
5313 return;
5314 }
5315
5316 if (!board_info->btdm_ant_det_finish) {
5317 psd_scan->ant_det_inteval_count =
5318 psd_scan->ant_det_inteval_count + 2;
5319
5320 if (psd_scan->ant_det_inteval_count >=
5321 BT_8723B_1ANT_ANTDET_RETRY_INTERVAL) {
5322 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5323 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is up, Try Detect!!\n");
5324 BTC_TRACE(trace_buf);
5325 halbtc8723b1ant_psd_antenna_detection_check(btcoexist);
5326
5327 if (board_info->btdm_ant_det_finish) {
5328 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5329 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Success!!\n");
5330 BTC_TRACE(trace_buf);
5331
5332
5333 #if 1
5334 if (board_info->btdm_ant_num_by_ant_det == 2)
5335 halbtc8723b1ant_mechanism_switch(
5336 btcoexist, true);
5337 else
5338 halbtc8723b1ant_mechanism_switch(
5339 btcoexist, false);
5340 #endif
5341
5342 board_info->btdm_ant_det_complete_fail = false;
5343
5344 } else {
5345 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5346 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Fail!!\n");
5347 BTC_TRACE(trace_buf);
5348
5349 board_info->btdm_ant_det_complete_fail = true;
5350 }
5351 psd_scan->ant_det_inteval_count = 0;
5352 } else {
5353 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5354 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is not up! (%d)\n",
5355 psd_scan->ant_det_inteval_count);
5356 BTC_TRACE(trace_buf);
5357 }
5358
5359 }
5360 #endif
5361
5362
5363 /*
5364 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
5365 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
5366
5367
5368 psd_scan->ant_det_bt_tx_time = seconds;
5369 psd_scan->ant_det_bt_le_channel = cent_freq;
5370
5371 if (seconds == 0)
5372 {
5373 psd_scan->ant_det_try_count = 0;
5374 psd_scan->ant_det_fail_count = 0;
5375 ant_det_count = 0;
5376 ant_det_fail_count = 0;
5377 board_info->btdm_ant_det_finish = false;
5378 board_info->btdm_ant_num_by_ant_det = 1;
5379 return;
5380 }
5381 else
5382 {
5383 ant_det_count++;
5384
5385 psd_scan->ant_det_try_count = ant_det_count;
5386
5387 if (scan ||roam)
5388 {
5389 board_info->btdm_ant_det_finish = false;
5390 psd_scan->ant_det_result = 6;
5391 }
5392 else if (coex_sta->num_of_profile >= 1)
5393 {
5394 board_info->btdm_ant_det_finish = false;
5395 psd_scan->ant_det_result = 7;
5396 }
5397 else if (!psd_scan->ant_det_is_ant_det_available)
5398 {
5399 board_info->btdm_ant_det_finish = false;
5400 psd_scan->ant_det_result = 9;
5401 }
5402 else if (coex_sta->c2h_bt_inquiry_page)
5403 {
5404 board_info->btdm_ant_det_finish = false;
5405 psd_scan->ant_det_result = 10;
5406 }
5407 else
5408 {
5409
5410 }
5411
5412 if (!board_info->btdm_ant_det_finish)
5413 ant_det_fail_count++;
5414
5415 psd_scan->ant_det_fail_count = ant_det_fail_count;
5416 }
5417 */
5418 }
5419
5420
5421 void ex_halbtc8723b1ant_display_ant_detection(IN struct btc_coexist *btcoexist)
5422 {
5423 #if BT_8723B_1ANT_ANTDET_ENABLE
5424 struct btc_board_info *board_info = &btcoexist->board_info;
5425
5426 if (psd_scan->ant_det_try_count != 0) {
5427 halbtc8723b1ant_psd_show_antenna_detect_result(btcoexist);
5428
5429 if (board_info->btdm_ant_det_finish)
5430 halbtc8723b1ant_psd_showdata(btcoexist);
5431 return;
5432 }
5433 #endif
5434
5435 /* halbtc8723b1ant_show_psd_data(btcoexist); */
5436 }
5437
5438 #endif
5439
5440 #endif /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */
5441
5442
5443
5444