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