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