?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / wireless / realtek / rtlwifi / btcoexist / halbtc8723b2ant.c
blob9f7b9af5bdcd4f3aeafcfe6764b35615ed282342
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2012 Realtek Corporation.*/
3
4 /***************************************************************
5 * Description:
6 *
7 * This file is for RTL8723B Co-exist mechanism
8 *
9 * History
10 * 2012/11/15 Cosa first check in.
11 *
12 **************************************************************/
13 /**************************************************************
14 * include files
15 **************************************************************/
16 #include "halbt_precomp.h"
17 /**************************************************************
18 * Global variables, these are static variables
19 **************************************************************/
20 static struct coex_dm_8723b_2ant glcoex_dm_8723b_2ant;
21 static struct coex_dm_8723b_2ant *coex_dm = &glcoex_dm_8723b_2ant;
22 static struct coex_sta_8723b_2ant glcoex_sta_8723b_2ant;
23 static struct coex_sta_8723b_2ant *coex_sta = &glcoex_sta_8723b_2ant;
24
25 static const char *const glbt_info_src_8723b_2ant[] = {
26 "BT Info[wifi fw]",
27 "BT Info[bt rsp]",
28 "BT Info[bt auto report]",
29 };
30
31 static u32 glcoex_ver_date_8723b_2ant = 20131113;
32 static u32 glcoex_ver_8723b_2ant = 0x3f;
33
34 /**************************************************************
35 * local function proto type if needed
36 **************************************************************/
37 /**************************************************************
38 * local function start with btc8723b2ant_
39 **************************************************************/
40 static u8 btc8723b2ant_bt_rssi_state(struct btc_coexist *btcoexist,
41 u8 level_num, u8 rssi_thresh,
42 u8 rssi_thresh1)
43 {
44 struct rtl_priv *rtlpriv = btcoexist->adapter;
45 s32 bt_rssi = 0;
46 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
47
48 bt_rssi = coex_sta->bt_rssi;
49
50 if (level_num == 2) {
51 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
52 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
53 if (bt_rssi >= rssi_thresh +
54 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
55 bt_rssi_state = BTC_RSSI_STATE_HIGH;
56 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
57 "[BTCoex], BT Rssi state switch to High\n");
58 } else {
59 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
60 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
61 "[BTCoex], BT Rssi state stay at Low\n");
62 }
63 } else {
64 if (bt_rssi < rssi_thresh) {
65 bt_rssi_state = BTC_RSSI_STATE_LOW;
66 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
67 "[BTCoex], BT Rssi state switch to Low\n");
68 } else {
69 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
70 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
71 "[BTCoex], BT Rssi state stay at High\n");
72 }
73 }
74 } else if (level_num == 3) {
75 if (rssi_thresh > rssi_thresh1) {
76 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
77 "[BTCoex], BT Rssi thresh error!!\n");
78 return coex_sta->pre_bt_rssi_state;
79 }
80
81 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
82 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
83 if (bt_rssi >= rssi_thresh +
84 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
85 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
86 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
87 "[BTCoex], BT Rssi state switch to Medium\n");
88 } else {
89 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
90 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
91 "[BTCoex], BT Rssi state stay at Low\n");
92 }
93 } else if ((coex_sta->pre_bt_rssi_state ==
94 BTC_RSSI_STATE_MEDIUM) ||
95 (coex_sta->pre_bt_rssi_state ==
96 BTC_RSSI_STATE_STAY_MEDIUM)) {
97 if (bt_rssi >= rssi_thresh1 +
98 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
99 bt_rssi_state = BTC_RSSI_STATE_HIGH;
100 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
101 "[BTCoex], BT Rssi state switch to High\n");
102 } else if (bt_rssi < rssi_thresh) {
103 bt_rssi_state = BTC_RSSI_STATE_LOW;
104 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
105 "[BTCoex], BT Rssi state switch to Low\n");
106 } else {
107 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
108 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
109 "[BTCoex], BT Rssi state stay at Medium\n");
110 }
111 } else {
112 if (bt_rssi < rssi_thresh1) {
113 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
114 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
115 "[BTCoex], BT Rssi state switch to Medium\n");
116 } else {
117 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
118 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
119 "[BTCoex], BT Rssi state stay at High\n");
120 }
121 }
122 }
123
124 coex_sta->pre_bt_rssi_state = bt_rssi_state;
125
126 return bt_rssi_state;
127 }
128
129 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
130 u8 index, u8 level_num,
131 u8 rssi_thresh, u8 rssi_thresh1)
132 {
133 struct rtl_priv *rtlpriv = btcoexist->adapter;
134 s32 wifi_rssi = 0;
135 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
136
137 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
138
139 if (level_num == 2) {
140 if ((coex_sta->pre_wifi_rssi_state[index] ==
141 BTC_RSSI_STATE_LOW) ||
142 (coex_sta->pre_wifi_rssi_state[index] ==
143 BTC_RSSI_STATE_STAY_LOW)) {
144 if (wifi_rssi >= rssi_thresh +
145 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
146 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
147 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
148 "[BTCoex], wifi RSSI state switch to High\n");
149 } else {
150 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
151 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
152 "[BTCoex], wifi RSSI state stay at Low\n");
153 }
154 } else {
155 if (wifi_rssi < rssi_thresh) {
156 wifi_rssi_state = BTC_RSSI_STATE_LOW;
157 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
158 "[BTCoex], wifi RSSI state switch to Low\n");
159 } else {
160 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
161 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
162 "[BTCoex], wifi RSSI state stay at High\n");
163 }
164 }
165 } else if (level_num == 3) {
166 if (rssi_thresh > rssi_thresh1) {
167 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
168 "[BTCoex], wifi RSSI thresh error!!\n");
169 return coex_sta->pre_wifi_rssi_state[index];
170 }
171
172 if ((coex_sta->pre_wifi_rssi_state[index] ==
173 BTC_RSSI_STATE_LOW) ||
174 (coex_sta->pre_wifi_rssi_state[index] ==
175 BTC_RSSI_STATE_STAY_LOW)) {
176 if (wifi_rssi >= rssi_thresh +
177 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
178 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
179 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
180 "[BTCoex], wifi RSSI state switch to Medium\n");
181 } else {
182 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
183 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
184 "[BTCoex], wifi RSSI state stay at Low\n");
185 }
186 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
187 BTC_RSSI_STATE_MEDIUM) ||
188 (coex_sta->pre_wifi_rssi_state[index] ==
189 BTC_RSSI_STATE_STAY_MEDIUM)) {
190 if (wifi_rssi >= rssi_thresh1 +
191 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
192 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
193 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
194 "[BTCoex], wifi RSSI state switch to High\n");
195 } else if (wifi_rssi < rssi_thresh) {
196 wifi_rssi_state = BTC_RSSI_STATE_LOW;
197 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
198 "[BTCoex], wifi RSSI state switch to Low\n");
199 } else {
200 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
201 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
202 "[BTCoex], wifi RSSI state stay at Medium\n");
203 }
204 } else {
205 if (wifi_rssi < rssi_thresh1) {
206 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
207 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
208 "[BTCoex], wifi RSSI state switch to Medium\n");
209 } else {
210 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
211 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
212 "[BTCoex], wifi RSSI state stay at High\n");
213 }
214 }
215 }
216
217 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
218
219 return wifi_rssi_state;
220 }
221
222 static
223 void btc8723b2ant_limited_rx(struct btc_coexist *btcoexist, bool force_exec,
224 bool rej_ap_agg_pkt, bool bt_ctrl_agg_buf_size,
225 u8 agg_buf_size)
226 {
227 bool reject_rx_agg = rej_ap_agg_pkt;
228 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
229 u8 rx_agg_size = agg_buf_size;
230
231 /* ============================================ */
232 /* Rx Aggregation related setting */
233 /* ============================================ */
234 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
235 &reject_rx_agg);
236 /* decide BT control aggregation buf size or not */
237 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
238 &bt_ctrl_rx_agg_size);
239 /* aggregate buf size, only work when BT control Rx aggregate size */
240 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
241 /* real update aggregation setting */
242 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
243 }
244
245 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
246 {
247 struct rtl_priv *rtlpriv = btcoexist->adapter;
248 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
249 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
250 u32 reg_hp_tx = 0, reg_hp_rx = 0;
251 u32 reg_lp_tx = 0, reg_lp_rx = 0;
252
253 reg_hp_txrx = 0x770;
254 reg_lp_txrx = 0x774;
255
256 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
257 reg_hp_tx = u32tmp & MASKLWORD;
258 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
259
260 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
261 reg_lp_tx = u32tmp & MASKLWORD;
262 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
263
264 coex_sta->high_priority_tx = reg_hp_tx;
265 coex_sta->high_priority_rx = reg_hp_rx;
266 coex_sta->low_priority_tx = reg_lp_tx;
267 coex_sta->low_priority_rx = reg_lp_rx;
268
269 if ((coex_sta->low_priority_tx > 1050) &&
270 (!coex_sta->c2h_bt_inquiry_page))
271 coex_sta->pop_event_cnt++;
272
273 if ((coex_sta->low_priority_rx >= 950) &&
274 (coex_sta->low_priority_rx >= coex_sta->low_priority_tx) &&
275 (!coex_sta->under_ips))
276 bt_link_info->slave_role = true;
277 else
278 bt_link_info->slave_role = false;
279
280 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
281 "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
282 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
283 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
284 "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
285 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
286
287 /* reset counter */
288 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
289 }
290
291 static void btc8723b2ant_monitor_wifi_ctr(struct btc_coexist *btcoexist)
292 {
293 if (coex_sta->under_ips) {
294 coex_sta->crc_ok_cck = 0;
295 coex_sta->crc_ok_11g = 0;
296 coex_sta->crc_ok_11n = 0;
297 coex_sta->crc_ok_11n_agg = 0;
298
299 coex_sta->crc_err_cck = 0;
300 coex_sta->crc_err_11g = 0;
301 coex_sta->crc_err_11n = 0;
302 coex_sta->crc_err_11n_agg = 0;
303 } else {
304 coex_sta->crc_ok_cck =
305 btcoexist->btc_read_4byte(btcoexist, 0xf88);
306 coex_sta->crc_ok_11g =
307 btcoexist->btc_read_2byte(btcoexist, 0xf94);
308 coex_sta->crc_ok_11n =
309 btcoexist->btc_read_2byte(btcoexist, 0xf90);
310 coex_sta->crc_ok_11n_agg =
311 btcoexist->btc_read_2byte(btcoexist, 0xfb8);
312
313 coex_sta->crc_err_cck =
314 btcoexist->btc_read_4byte(btcoexist, 0xf84);
315 coex_sta->crc_err_11g =
316 btcoexist->btc_read_2byte(btcoexist, 0xf96);
317 coex_sta->crc_err_11n =
318 btcoexist->btc_read_2byte(btcoexist, 0xf92);
319 coex_sta->crc_err_11n_agg =
320 btcoexist->btc_read_2byte(btcoexist, 0xfba);
321 }
322
323 /* reset counter */
324 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1);
325 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0);
326 }
327
328 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist)
329 {
330 struct rtl_priv *rtlpriv = btcoexist->adapter;
331 u8 h2c_parameter[1] = {0};
332
333 coex_sta->c2h_bt_info_req_sent = true;
334
335 h2c_parameter[0] |= BIT0; /* trigger */
336
337 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
338 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
339 h2c_parameter[0]);
340
341 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
342 }
343
344 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
345 {
346 static bool pre_wifi_busy;
347 static bool pre_under_4way;
348 static bool pre_bt_hs_on;
349 bool wifi_busy = false, under_4way = false, bt_hs_on = false;
350 bool wifi_connected = false;
351 u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
352 u8 tmp;
353
354 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
355 &wifi_connected);
356 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
357 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
358 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
359 &under_4way);
360
361 if (wifi_connected) {
362 if (wifi_busy != pre_wifi_busy) {
363 pre_wifi_busy = wifi_busy;
364 return true;
365 }
366
367 if (under_4way != pre_under_4way) {
368 pre_under_4way = under_4way;
369 return true;
370 }
371
372 if (bt_hs_on != pre_bt_hs_on) {
373 pre_bt_hs_on = bt_hs_on;
374 return true;
375 }
376
377 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
378 coex_dm->switch_thres_offset;
379 wifi_rssi_state =
380 btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
381
382 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
383 (wifi_rssi_state == BTC_RSSI_STATE_LOW))
384 return true;
385 }
386
387 return false;
388 }
389
390 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
391 {
392 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
393 bool bt_hs_on = false;
394
395 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
396
397 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
398 bt_link_info->sco_exist = coex_sta->sco_exist;
399 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
400 bt_link_info->pan_exist = coex_sta->pan_exist;
401 bt_link_info->hid_exist = coex_sta->hid_exist;
402
403 /* work around for HS mode. */
404 if (bt_hs_on) {
405 bt_link_info->pan_exist = true;
406 bt_link_info->bt_link_exist = true;
407 }
408
409 /* check if Sco only */
410 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
411 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
412 bt_link_info->sco_only = true;
413 else
414 bt_link_info->sco_only = false;
415
416 /* check if A2dp only */
417 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
418 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
419 bt_link_info->a2dp_only = true;
420 else
421 bt_link_info->a2dp_only = false;
422
423 /* check if Pan only */
424 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
425 bt_link_info->pan_exist && !bt_link_info->hid_exist)
426 bt_link_info->pan_only = true;
427 else
428 bt_link_info->pan_only = false;
429
430 /* check if Hid only */
431 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
432 !bt_link_info->pan_exist && bt_link_info->hid_exist)
433 bt_link_info->hid_only = true;
434 else
435 bt_link_info->hid_only = false;
436 }
437
438 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
439 {
440 struct rtl_priv *rtlpriv = btcoexist->adapter;
441 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
442 bool bt_hs_on = false;
443 u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
444 u8 num_of_diff_profile = 0;
445
446 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
447
448 if (!bt_link_info->bt_link_exist) {
449 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
450 "[BTCoex], No BT link exists!!!\n");
451 return algorithm;
452 }
453
454 if (bt_link_info->sco_exist)
455 num_of_diff_profile++;
456 if (bt_link_info->hid_exist)
457 num_of_diff_profile++;
458 if (bt_link_info->pan_exist)
459 num_of_diff_profile++;
460 if (bt_link_info->a2dp_exist)
461 num_of_diff_profile++;
462
463 if (num_of_diff_profile == 1) {
464 if (bt_link_info->sco_exist) {
465 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
466 "[BTCoex], SCO only\n");
467 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
468 } else {
469 if (bt_link_info->hid_exist) {
470 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
471 "[BTCoex], HID only\n");
472 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
473 } else if (bt_link_info->a2dp_exist) {
474 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
475 "[BTCoex], A2DP only\n");
476 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
477 } else if (bt_link_info->pan_exist) {
478 if (bt_hs_on) {
479 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
480 DBG_LOUD,
481 "[BTCoex], PAN(HS) only\n");
482 algorithm =
483 BT_8723B_2ANT_COEX_ALGO_PANHS;
484 } else {
485 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
486 DBG_LOUD,
487 "[BTCoex], PAN(EDR) only\n");
488 algorithm =
489 BT_8723B_2ANT_COEX_ALGO_PANEDR;
490 }
491 }
492 }
493 } else if (num_of_diff_profile == 2) {
494 if (bt_link_info->sco_exist) {
495 if (bt_link_info->hid_exist) {
496 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
497 "[BTCoex], SCO + HID\n");
498 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
499 } else if (bt_link_info->a2dp_exist) {
500 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
501 "[BTCoex], SCO + A2DP ==> SCO\n");
502 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
503 } else if (bt_link_info->pan_exist) {
504 if (bt_hs_on) {
505 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
506 DBG_LOUD,
507 "[BTCoex], SCO + PAN(HS)\n");
508 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
509 } else {
510 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
511 DBG_LOUD,
512 "[BTCoex], SCO + PAN(EDR)\n");
513 algorithm =
514 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
515 }
516 }
517 } else {
518 if (bt_link_info->hid_exist &&
519 bt_link_info->a2dp_exist) {
520 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
521 "[BTCoex], HID + A2DP\n");
522 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
523 } else if (bt_link_info->hid_exist &&
524 bt_link_info->pan_exist) {
525 if (bt_hs_on) {
526 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
527 DBG_LOUD,
528 "[BTCoex], HID + PAN(HS)\n");
529 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
530 } else {
531 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
532 DBG_LOUD,
533 "[BTCoex], HID + PAN(EDR)\n");
534 algorithm =
535 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
536 }
537 } else if (bt_link_info->pan_exist &&
538 bt_link_info->a2dp_exist) {
539 if (bt_hs_on) {
540 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
541 DBG_LOUD,
542 "[BTCoex], A2DP + PAN(HS)\n");
543 algorithm =
544 BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
545 } else {
546 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
547 DBG_LOUD,
548 "[BTCoex],A2DP + PAN(EDR)\n");
549 algorithm =
550 BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
551 }
552 }
553 }
554 } else if (num_of_diff_profile == 3) {
555 if (bt_link_info->sco_exist) {
556 if (bt_link_info->hid_exist &&
557 bt_link_info->a2dp_exist) {
558 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
559 "[BTCoex], SCO + HID + A2DP ==> HID\n");
560 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
561 } else if (bt_link_info->hid_exist &&
562 bt_link_info->pan_exist) {
563 if (bt_hs_on) {
564 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
565 DBG_LOUD,
566 "[BTCoex], SCO + HID + PAN(HS)\n");
567 algorithm =
568 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
569 } else {
570 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
571 DBG_LOUD,
572 "[BTCoex], SCO + HID + PAN(EDR)\n");
573 algorithm =
574 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
575 }
576 } else if (bt_link_info->pan_exist &&
577 bt_link_info->a2dp_exist) {
578 if (bt_hs_on) {
579 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
580 DBG_LOUD,
581 "[BTCoex], SCO + A2DP + PAN(HS)\n");
582 algorithm =
583 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
584 } else {
585 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
586 DBG_LOUD,
587 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
588 algorithm =
589 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
590 }
591 }
592 } else {
593 if (bt_link_info->hid_exist &&
594 bt_link_info->pan_exist &&
595 bt_link_info->a2dp_exist) {
596 if (bt_hs_on) {
597 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
598 DBG_LOUD,
599 "[BTCoex], HID + A2DP + PAN(HS)\n");
600 algorithm =
601 BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
602 } else {
603 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
604 DBG_LOUD,
605 "[BTCoex], HID + A2DP + PAN(EDR)\n");
606 algorithm =
607 BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
608 }
609 }
610 }
611 } else if (num_of_diff_profile >= 3) {
612 if (bt_link_info->sco_exist) {
613 if (bt_link_info->hid_exist &&
614 bt_link_info->pan_exist &&
615 bt_link_info->a2dp_exist) {
616 if (bt_hs_on) {
617 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
618 DBG_LOUD,
619 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
620 } else {
621 RT_TRACE(rtlpriv, COMP_BT_COEXIST,
622 DBG_LOUD,
623 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
624 algorithm =
625 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
626 }
627 }
628 }
629 }
630 return algorithm;
631 }
632
633 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
634 u8 dac_swing_lvl)
635 {
636 struct rtl_priv *rtlpriv = btcoexist->adapter;
637 u8 h2c_parameter[1] = {0};
638
639 /* There are several type of dacswing
640 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
641 */
642 h2c_parameter[0] = dac_swing_lvl;
643
644 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
645 "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
646 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
647 "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
648
649 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
650 }
651
652 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
653 u8 dec_bt_pwr_lvl)
654 {
655 struct rtl_priv *rtlpriv = btcoexist->adapter;
656 u8 h2c_parameter[1] = {0};
657
658 h2c_parameter[0] = dec_bt_pwr_lvl;
659
660 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
661 "[BTCoex], decrease Bt Power Level : %u\n", dec_bt_pwr_lvl);
662
663 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
664 }
665
666 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
667 bool force_exec, u8 dec_bt_pwr_lvl)
668 {
669 struct rtl_priv *rtlpriv = btcoexist->adapter;
670
671 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
672 "[BTCoex], Dec BT power level = %u\n", dec_bt_pwr_lvl);
673 coex_dm->cur_dec_bt_pwr_lvl = dec_bt_pwr_lvl;
674
675 if (!force_exec) {
676 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
677 "[BTCoex], PreDecBtPwrLvl=%d, CurDecBtPwrLvl=%d\n",
678 coex_dm->pre_dec_bt_pwr_lvl,
679 coex_dm->cur_dec_bt_pwr_lvl);
680
681 if (coex_dm->pre_dec_bt_pwr_lvl == coex_dm->cur_dec_bt_pwr_lvl)
682 return;
683 }
684 btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr_lvl);
685
686 coex_dm->pre_dec_bt_pwr_lvl = coex_dm->cur_dec_bt_pwr_lvl;
687 }
688
689 static
690 void halbtc8723b2ant_set_bt_auto_report(struct btc_coexist *btcoexist,
691 bool enable_auto_report)
692 {
693 u8 h2c_parameter[1] = {0};
694
695 h2c_parameter[0] = 0;
696
697 if (enable_auto_report)
698 h2c_parameter[0] |= BIT(0);
699
700 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
701 }
702
703 static
704 void btc8723b2ant_bt_auto_report(struct btc_coexist *btcoexist,
705 bool force_exec, bool enable_auto_report)
706 {
707 coex_dm->cur_bt_auto_report = enable_auto_report;
708
709 if (!force_exec) {
710 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
711 return;
712 }
713 halbtc8723b2ant_set_bt_auto_report(btcoexist,
714 coex_dm->cur_bt_auto_report);
715
716 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
717 }
718
719 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
720 bool force_exec, u8 fw_dac_swing_lvl)
721 {
722 struct rtl_priv *rtlpriv = btcoexist->adapter;
723
724 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
725 "[BTCoex], %s set FW Dac Swing level = %d\n",
726 (force_exec ? "force to" : ""), fw_dac_swing_lvl);
727 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
728
729 if (!force_exec) {
730 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
731 "[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
732 coex_dm->pre_fw_dac_swing_lvl,
733 coex_dm->cur_fw_dac_swing_lvl);
734
735 if (coex_dm->pre_fw_dac_swing_lvl ==
736 coex_dm->cur_fw_dac_swing_lvl)
737 return;
738 }
739
740 btc8723b2ant_set_fw_dac_swing_level(btcoexist,
741 coex_dm->cur_fw_dac_swing_lvl);
742 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
743 }
744
745 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
746 bool low_penalty_ra)
747 {
748 struct rtl_priv *rtlpriv = btcoexist->adapter;
749 u8 h2c_parameter[6] = {0};
750
751 h2c_parameter[0] = 0x6; /* op_code, 0x6 = Retry_Penalty */
752
753 if (low_penalty_ra) {
754 h2c_parameter[1] |= BIT0;
755 /* normal rate except MCS7/6/5, OFDM54/48/36 */
756 h2c_parameter[2] = 0x00;
757 h2c_parameter[3] = 0xf4; /* MCS7 or OFDM54 */
758 h2c_parameter[4] = 0xf5; /* MCS6 or OFDM48 */
759 h2c_parameter[5] = 0xf6; /* MCS5 or OFDM36 */
760 }
761
762 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
763 "[BTCoex], set WiFi Low-Penalty Retry: %s",
764 (low_penalty_ra ? "ON!!" : "OFF!!"));
765
766 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
767 }
768
769 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
770 bool force_exec, bool low_penalty_ra)
771 {
772 struct rtl_priv *rtlpriv = btcoexist->adapter;
773
774 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
775 "[BTCoex], %s turn LowPenaltyRA = %s\n",
776 (force_exec ? "force to" : ""), (low_penalty_ra ?
777 "ON" : "OFF"));
778 coex_dm->cur_low_penalty_ra = low_penalty_ra;
779
780 if (!force_exec) {
781 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
782 "[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
783 coex_dm->pre_low_penalty_ra,
784 coex_dm->cur_low_penalty_ra);
785
786 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
787 return;
788 }
789 btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
790
791 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
792 }
793
794 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
795 u32 level)
796 {
797 struct rtl_priv *rtlpriv = btcoexist->adapter;
798 u8 val = (u8) level;
799
800 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
801 "[BTCoex], Write SwDacSwing = 0x%x\n", level);
802 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
803 }
804
805 static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex,
806 bool sw_dac_swing_on,
807 u32 sw_dac_swing_lvl)
808 {
809 if (sw_dac_swing_on)
810 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
811 else
812 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
813 }
814
815 static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
816 bool force_exec, bool dac_swing_on,
817 u32 dac_swing_lvl)
818 {
819 struct rtl_priv *rtlpriv = btcoexist->adapter;
820
821 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
822 "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
823 (force_exec ? "force to" : ""),
824 (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
825 coex_dm->cur_dac_swing_on = dac_swing_on;
826 coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
827
828 if (!force_exec) {
829 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
830 "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
831 coex_dm->pre_dac_swing_on,
832 coex_dm->pre_dac_swing_lvl,
833 coex_dm->cur_dac_swing_on,
834 coex_dm->cur_dac_swing_lvl);
835
836 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
837 (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
838 return;
839 }
840 mdelay(30);
841 btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
842 dac_swing_lvl);
843
844 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
845 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
846 }
847
848 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
849 u32 val0x6c0, u32 val0x6c4,
850 u32 val0x6c8, u8 val0x6cc)
851 {
852 struct rtl_priv *rtlpriv = btcoexist->adapter;
853
854 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
855 "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
856 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
857
858 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
859 "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
860 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
861
862 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
863 "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
864 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
865
866 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
867 "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
868 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
869 }
870
871 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
872 bool force_exec, u32 val0x6c0,
873 u32 val0x6c4, u32 val0x6c8,
874 u8 val0x6cc)
875 {
876 struct rtl_priv *rtlpriv = btcoexist->adapter;
877
878 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
879 "[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
880 force_exec ? "force to" : "",
881 val0x6c0, val0x6c4, val0x6c8, val0x6cc);
882 coex_dm->cur_val0x6c0 = val0x6c0;
883 coex_dm->cur_val0x6c4 = val0x6c4;
884 coex_dm->cur_val0x6c8 = val0x6c8;
885 coex_dm->cur_val0x6cc = val0x6cc;
886
887 if (!force_exec) {
888 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
889 "[BTCoex], preVal0x6c0=0x%x, preVal0x6c4=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
890 coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
891 coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
892 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
893 "[BTCoex], curVal0x6c0=0x%x, curVal0x6c4=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
894 coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
895 coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
896
897 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
898 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
899 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
900 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
901 return;
902 }
903 btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
904 val0x6c8, val0x6cc);
905
906 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
907 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
908 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
909 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
910 }
911
912 static void btc8723b2ant_coex_table_with_type(struct btc_coexist *btcoexist,
913 bool force_exec, u8 type)
914 {
915 switch (type) {
916 case 0:
917 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
918 0x55555555, 0xffffff, 0x3);
919 break;
920 case 1:
921 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
922 0x5afa5afa, 0xffffff, 0x3);
923 break;
924 case 2:
925 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5ada5ada,
926 0x5ada5ada, 0xffffff, 0x3);
927 break;
928 case 3:
929 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
930 0xaaaaaaaa, 0xffffff, 0x3);
931 break;
932 case 4:
933 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
934 0xffffffff, 0xffffff, 0x3);
935 break;
936 case 5:
937 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
938 0x5fff5fff, 0xffffff, 0x3);
939 break;
940 case 6:
941 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
942 0x5a5a5a5a, 0xffffff, 0x3);
943 break;
944 case 7:
945 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
946 0x5ada5ada, 0xffffff, 0x3);
947 break;
948 case 8:
949 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
950 0x5ada5ada, 0xffffff, 0x3);
951 break;
952 case 9:
953 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
954 0x5ada5ada, 0xffffff, 0x3);
955 break;
956 case 10:
957 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
958 0x5ada5ada, 0xffffff, 0x3);
959 break;
960 case 11:
961 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
962 0x5ada5ada, 0xffffff, 0x3);
963 break;
964 case 12:
965 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
966 0x5ada5ada, 0xffffff, 0x3);
967 break;
968 case 13:
969 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
970 0xaaaaaaaa, 0xffffff, 0x3);
971 break;
972 case 14:
973 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
974 0x5ada5ada, 0xffffff, 0x3);
975 break;
976 case 15:
977 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55dd55dd,
978 0xaaaaaaaa, 0xffffff, 0x3);
979 break;
980 default:
981 break;
982 }
983 }
984
985 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
986 bool enable)
987 {
988 struct rtl_priv *rtlpriv = btcoexist->adapter;
989 u8 h2c_parameter[1] = {0};
990
991 if (enable)
992 h2c_parameter[0] |= BIT0; /* function enable */
993
994 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
995 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63=0x%x\n",
996 h2c_parameter[0]);
997
998 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
999 }
1000
1001 static void btc8723b2ant_set_lps_rpwm(struct btc_coexist *btcoexist,
1002 u8 lps_val, u8 rpwm_val)
1003 {
1004 u8 lps = lps_val;
1005 u8 rpwm = rpwm_val;
1006
1007 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1008 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1009 }
1010
1011 static void btc8723b2ant_lps_rpwm(struct btc_coexist *btcoexist,
1012 bool force_exec, u8 lps_val, u8 rpwm_val)
1013 {
1014 coex_dm->cur_lps = lps_val;
1015 coex_dm->cur_rpwm = rpwm_val;
1016
1017 if (!force_exec) {
1018 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1019 (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1020 return;
1021 }
1022 btc8723b2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1023
1024 coex_dm->pre_lps = coex_dm->cur_lps;
1025 coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1026 }
1027
1028 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1029 bool force_exec, bool enable)
1030 {
1031 struct rtl_priv *rtlpriv = btcoexist->adapter;
1032
1033 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1034 "[BTCoex], %s turn Ignore WlanAct %s\n",
1035 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1036 coex_dm->cur_ignore_wlan_act = enable;
1037
1038 if (!force_exec) {
1039 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1040 "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1041 coex_dm->pre_ignore_wlan_act,
1042 coex_dm->cur_ignore_wlan_act);
1043
1044 if (coex_dm->pre_ignore_wlan_act ==
1045 coex_dm->cur_ignore_wlan_act)
1046 return;
1047 }
1048 btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1049
1050 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1051 }
1052
1053 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1054 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1055 {
1056 struct rtl_priv *rtlpriv = btcoexist->adapter;
1057 u8 h2c_parameter[5];
1058 if ((coex_sta->a2dp_exist) && (coex_sta->hid_exist))
1059 byte5 = byte5 | 0x1;
1060
1061 h2c_parameter[0] = byte1;
1062 h2c_parameter[1] = byte2;
1063 h2c_parameter[2] = byte3;
1064 h2c_parameter[3] = byte4;
1065 h2c_parameter[4] = byte5;
1066
1067 coex_dm->ps_tdma_para[0] = byte1;
1068 coex_dm->ps_tdma_para[1] = byte2;
1069 coex_dm->ps_tdma_para[2] = byte3;
1070 coex_dm->ps_tdma_para[3] = byte4;
1071 coex_dm->ps_tdma_para[4] = byte5;
1072
1073 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1074 "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1075 h2c_parameter[0],
1076 h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1077 h2c_parameter[3] << 8 | h2c_parameter[4]);
1078
1079 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1080 }
1081
1082 static void btc8723b2ant_sw_mechanism(struct btc_coexist *btcoexist,
1083 bool shrink_rx_lpf, bool low_penalty_ra,
1084 bool limited_dig, bool bt_lna_constrain)
1085 {
1086 btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1087 }
1088
1089 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist,
1090 u8 antpos_type, bool init_hwcfg,
1091 bool wifi_off)
1092 {
1093 struct btc_board_info *board_info = &btcoexist->board_info;
1094 u32 fw_ver = 0, u32tmp = 0;
1095 bool pg_ext_switch = false;
1096 bool use_ext_switch = false;
1097 u8 h2c_parameter[2] = {0};
1098
1099 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch);
1100 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
1101
1102 if ((fw_ver < 0xc0000) || pg_ext_switch)
1103 use_ext_switch = true;
1104
1105 if (init_hwcfg) {
1106 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1);
1107 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
1108 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
1109 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
1110 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
1111
1112 if (fw_ver >= 0x180000) {
1113 /* Use H2C to set GNT_BT to High to avoid A2DP click */
1114 h2c_parameter[0] = 1;
1115 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1116 h2c_parameter);
1117 } else {
1118 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
1119 }
1120
1121 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
1122
1123 /* WiFi TRx Mask off */
1124 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1125 0x1, 0xfffff, 0x0);
1126
1127 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1128 /* tell firmware "no antenna inverse" */
1129 h2c_parameter[0] = 0;
1130 } else {
1131 /* tell firmware "antenna inverse" */
1132 h2c_parameter[0] = 1;
1133 }
1134
1135 if (use_ext_switch) {
1136 /* ext switch type */
1137 h2c_parameter[1] = 1;
1138 } else {
1139 /* int switch type */
1140 h2c_parameter[1] = 0;
1141 }
1142 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, h2c_parameter);
1143 } else {
1144 if (fw_ver >= 0x180000) {
1145 /* Use H2C to set GNT_BT to "Control by PTA"*/
1146 h2c_parameter[0] = 0;
1147 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1,
1148 h2c_parameter);
1149 } else {
1150 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0);
1151 }
1152 }
1153
1154 /* ext switch setting */
1155 if (use_ext_switch) {
1156 if (init_hwcfg) {
1157 /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1158 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1159 u32tmp &= ~BIT23;
1160 u32tmp |= BIT24;
1161 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1162 }
1163
1164 /* fixed internal switch S1->WiFi, S0->BT */
1165 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1166 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1167 else
1168 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1169
1170 switch (antpos_type) {
1171 case BTC_ANT_WIFI_AT_MAIN:
1172 /* ext switch main at wifi */
1173 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
1174 0x3, 0x1);
1175 break;
1176 case BTC_ANT_WIFI_AT_AUX:
1177 /* ext switch aux at wifi */
1178 btcoexist->btc_write_1byte_bitmask(btcoexist,
1179 0x92c, 0x3, 0x2);
1180 break;
1181 }
1182 } else {
1183 /* internal switch */
1184 if (init_hwcfg) {
1185 /* 0x4c[23] = 0, 0x4c[24] = 1 Ant controlled by WL/BT */
1186 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1187 u32tmp |= BIT23;
1188 u32tmp &= ~BIT24;
1189 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
1190 }
1191
1192 /* fixed ext switch, S1->Main, S0->Aux */
1193 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x0);
1194 switch (antpos_type) {
1195 case BTC_ANT_WIFI_AT_MAIN:
1196 /* fixed internal switch S1->WiFi, S0->BT */
1197 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
1198 break;
1199 case BTC_ANT_WIFI_AT_AUX:
1200 /* fixed internal switch S0->WiFi, S1->BT */
1201 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1202 break;
1203 }
1204 }
1205 }
1206
1207 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1208 bool turn_on, u8 type)
1209 {
1210 struct rtl_priv *rtlpriv = btcoexist->adapter;
1211 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1212 u8 wifi_rssi_state, bt_rssi_state;
1213 s8 wifi_duration_adjust = 0x0;
1214 u8 tdma_byte4_modify = 0x0;
1215 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1216 coex_dm->switch_thres_offset;
1217
1218 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, tmp, 0);
1219 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1220 coex_dm->switch_thres_offset;
1221 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1222
1223 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1224 "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1225 (force_exec ? "force to" : ""),
1226 (turn_on ? "ON" : "OFF"), type);
1227 coex_dm->cur_ps_tdma_on = turn_on;
1228 coex_dm->cur_ps_tdma = type;
1229
1230 if (!(BTC_RSSI_HIGH(wifi_rssi_state) &&
1231 BTC_RSSI_HIGH(bt_rssi_state)) && turn_on) {
1232 /* for WiFi RSSI low or BT RSSI low */
1233 type = type + 100;
1234 coex_dm->is_switch_to_1dot5_ant = true;
1235 } else {
1236 coex_dm->is_switch_to_1dot5_ant = false;
1237 }
1238
1239 if (!force_exec) {
1240 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1241 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1242 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1243 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1244 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1245 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1246
1247 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1248 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1249 return;
1250 }
1251
1252 if (coex_sta->scan_ap_num <= 5) {
1253 if (coex_sta->a2dp_bit_pool >= 45)
1254 wifi_duration_adjust = -15;
1255 else if (coex_sta->a2dp_bit_pool >= 35)
1256 wifi_duration_adjust = -10;
1257 else
1258 wifi_duration_adjust = 5;
1259 } else if (coex_sta->scan_ap_num <= 20) {
1260 if (coex_sta->a2dp_bit_pool >= 45)
1261 wifi_duration_adjust = -15;
1262 else if (coex_sta->a2dp_bit_pool >= 35)
1263 wifi_duration_adjust = -10;
1264 else
1265 wifi_duration_adjust = 0;
1266 } else if (coex_sta->scan_ap_num <= 40) {
1267 if (coex_sta->a2dp_bit_pool >= 45)
1268 wifi_duration_adjust = -15;
1269 else if (coex_sta->a2dp_bit_pool >= 35)
1270 wifi_duration_adjust = -10;
1271 else
1272 wifi_duration_adjust = -5;
1273 } else {
1274 if (coex_sta->a2dp_bit_pool >= 45)
1275 wifi_duration_adjust = -15;
1276 else if (coex_sta->a2dp_bit_pool >= 35)
1277 wifi_duration_adjust = -10;
1278 else
1279 wifi_duration_adjust = -10;
1280 }
1281
1282 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1283 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1284 tdma_byte4_modify = 0x1;
1285
1286 if (turn_on) {
1287 switch (type) {
1288 case 1:
1289 default:
1290 btc8723b2ant_set_fw_ps_tdma(
1291 btcoexist, 0xe3, 0x3c,
1292 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1293 break;
1294 case 2:
1295 btc8723b2ant_set_fw_ps_tdma(
1296 btcoexist, 0xe3, 0x2d,
1297 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1298 break;
1299 case 3:
1300 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1301 0x3, 0xf1,
1302 0x90 | tdma_byte4_modify);
1303 break;
1304 case 4:
1305 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1306 0x03, 0xf1,
1307 0x90 | tdma_byte4_modify);
1308 break;
1309 case 5:
1310 btc8723b2ant_set_fw_ps_tdma(
1311 btcoexist, 0xe3, 0x3c,
1312 0x3, 0x70, 0x90 | tdma_byte4_modify);
1313 break;
1314 case 6:
1315 btc8723b2ant_set_fw_ps_tdma(
1316 btcoexist, 0xe3, 0x2d,
1317 0x3, 0x70, 0x90 | tdma_byte4_modify);
1318 break;
1319 case 7:
1320 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1321 0x3, 0x70,
1322 0x90 | tdma_byte4_modify);
1323 break;
1324 case 8:
1325 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1326 0x3, 0x70,
1327 0x90 | tdma_byte4_modify);
1328 break;
1329 case 9:
1330 btc8723b2ant_set_fw_ps_tdma(
1331 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1332 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1333 break;
1334 case 10:
1335 btc8723b2ant_set_fw_ps_tdma(
1336 btcoexist, 0xe3, 0x2d,
1337 0x03, 0xf1, 0x90 | tdma_byte4_modify);
1338 break;
1339 case 11:
1340 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1341 0x3, 0xf1,
1342 0x90 | tdma_byte4_modify);
1343 break;
1344 case 12:
1345 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1346 0x3, 0xf1,
1347 0x90 | tdma_byte4_modify);
1348 break;
1349 case 13:
1350 btc8723b2ant_set_fw_ps_tdma(
1351 btcoexist, 0xe3, 0x3c,
1352 0x3, 0x70, 0x90 | tdma_byte4_modify);
1353 break;
1354 case 14:
1355 btc8723b2ant_set_fw_ps_tdma(
1356 btcoexist, 0xe3, 0x2d,
1357 0x3, 0x70, 0x90 | tdma_byte4_modify);
1358 break;
1359 case 15:
1360 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1361 0x3, 0x70,
1362 0x90 | tdma_byte4_modify);
1363 break;
1364 case 16:
1365 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1366 0x3, 0x70,
1367 0x90 | tdma_byte4_modify);
1368 break;
1369 case 17:
1370 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1371 0x2f, 0x60, 0x90);
1372 break;
1373 case 18:
1374 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 0x5,
1375 0xe1, 0x90);
1376 break;
1377 case 19:
1378 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1379 0x25, 0xe1, 0x90);
1380 break;
1381 case 20:
1382 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1383 0x25, 0x60, 0x90);
1384 break;
1385 case 21:
1386 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1387 0x03, 0x70, 0x90);
1388 break;
1389
1390 case 23:
1391 case 123:
1392 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1393 0x03, 0x71, 0x10);
1394 break;
1395 case 71:
1396 btc8723b2ant_set_fw_ps_tdma(
1397 btcoexist, 0xe3, 0x3c + wifi_duration_adjust,
1398 0x03, 0xf1, 0x90);
1399 break;
1400 case 101:
1401 case 105:
1402 case 113:
1403 case 171:
1404 btc8723b2ant_set_fw_ps_tdma(
1405 btcoexist, 0xd3, 0x3a + wifi_duration_adjust,
1406 0x03, 0x70, 0x50 | tdma_byte4_modify);
1407 break;
1408 case 102:
1409 case 106:
1410 case 110:
1411 case 114:
1412 btc8723b2ant_set_fw_ps_tdma(
1413 btcoexist, 0xd3, 0x2d + wifi_duration_adjust,
1414 0x03, 0x70, 0x50 | tdma_byte4_modify);
1415 break;
1416 case 103:
1417 case 107:
1418 case 111:
1419 case 115:
1420 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1c,
1421 0x03, 0x70,
1422 0x50 | tdma_byte4_modify);
1423 break;
1424 case 104:
1425 case 108:
1426 case 112:
1427 case 116:
1428 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x10,
1429 0x03, 0x70,
1430 0x50 | tdma_byte4_modify);
1431 break;
1432 case 109:
1433 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x3c,
1434 0x03, 0xf1,
1435 0x90 | tdma_byte4_modify);
1436 break;
1437 case 121:
1438 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1439 0x03, 0x70,
1440 0x90 | tdma_byte4_modify);
1441 break;
1442 case 22:
1443 case 122:
1444 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x35,
1445 0x03, 0x71, 0x11);
1446 break;
1447 }
1448 } else {
1449 /* disable PS tdma */
1450 switch (type) {
1451 case 0:
1452 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1453 0x40, 0x0);
1454 break;
1455 case 1:
1456 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1457 0x48, 0x0);
1458 break;
1459 default:
1460 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1461 0x40, 0x0);
1462 break;
1463 }
1464 }
1465
1466 /* update pre state */
1467 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1468 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1469 }
1470
1471 static void btc8723b2ant_ps_tdma_check_for_power_save_state(
1472 struct btc_coexist *btcoexist, bool new_ps_state)
1473 {
1474 u8 lps_mode = 0x0;
1475
1476 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1477
1478 if (lps_mode) {
1479 /* already under LPS state */
1480 if (new_ps_state) {
1481 /* keep state under LPS, do nothing. */
1482 } else {
1483 /* will leave LPS state, turn off psTdma first */
1484 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1485 }
1486 } else {
1487 /* NO PS state */
1488 if (new_ps_state) {
1489 /* will enter LPS state, turn off psTdma first */
1490 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1491 } else {
1492 /* keep state under NO PS state, do nothing. */
1493 }
1494 }
1495 }
1496
1497 static void btc8723b2ant_power_save_state(struct btc_coexist *btcoexist,
1498 u8 ps_type, u8 lps_val, u8 rpwm_val)
1499 {
1500 bool low_pwr_disable = false;
1501
1502 switch (ps_type) {
1503 case BTC_PS_WIFI_NATIVE:
1504 /* recover to original 32k low power setting */
1505 low_pwr_disable = false;
1506 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1507 &low_pwr_disable);
1508 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1509 coex_sta->force_lps_on = false;
1510 break;
1511 case BTC_PS_LPS_ON:
1512 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1513 true);
1514 btc8723b2ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1515 rpwm_val);
1516 /* when coex force to enter LPS, do not enter 32k low power */
1517 low_pwr_disable = true;
1518 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1519 &low_pwr_disable);
1520 /* power save must executed before psTdma */
1521 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1522 coex_sta->force_lps_on = true;
1523 break;
1524 case BTC_PS_LPS_OFF:
1525 btc8723b2ant_ps_tdma_check_for_power_save_state(btcoexist,
1526 false);
1527 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1528 coex_sta->force_lps_on = false;
1529 break;
1530 default:
1531 break;
1532 }
1533 }
1534
1535 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1536 {
1537 /* fw all off */
1538 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1539 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1540 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1541 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1542
1543 /* sw all off */
1544 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1545
1546 /* hw all off */
1547 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1548 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1549 }
1550
1551 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1552 {
1553 /* force to reset coex mechanism*/
1554 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1555 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1556
1557 btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1558 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1559 btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, 0);
1560
1561 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1562
1563 coex_sta->pop_event_cnt = 0;
1564 }
1565
1566 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1567 {
1568 struct rtl_priv *rtlpriv = btcoexist->adapter;
1569 bool wifi_connected = false;
1570 bool low_pwr_disable = true;
1571 bool scan = false, link = false, roam = false;
1572
1573 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1574 &low_pwr_disable);
1575 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1576 &wifi_connected);
1577
1578 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1579 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1580 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1581
1582 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1583
1584 if (coex_sta->bt_abnormal_scan) {
1585 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
1586 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 3);
1587 } else if (scan || link || roam) {
1588 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1589 "[BTCoex], Wifi link process + BT Inq/Page!!\n");
1590 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1591 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1592 } else if (wifi_connected) {
1593 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1594 "[BTCoex], Wifi connected + BT Inq/Page!!\n");
1595 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1596 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1597 } else {
1598 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1599 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1600 }
1601 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1602 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1603
1604 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1605 }
1606
1607 static void btc8723b2ant_action_wifi_link_process(struct btc_coexist
1608 *btcoexist)
1609 {
1610 struct rtl_priv *rtlpriv = btcoexist->adapter;
1611 u32 u32tmp;
1612 u8 u8tmpa, u8tmpb;
1613
1614 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 15);
1615 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1616
1617 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
1618
1619 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
1620 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
1621 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
1622
1623 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1624 "[BTCoex], 0x948 = 0x%x, 0x765 = 0x%x, 0x76e = 0x%x\n",
1625 u32tmp, u8tmpa, u8tmpb);
1626 }
1627
1628 static bool btc8723b2ant_action_wifi_idle_process(struct btc_coexist *btcoexist)
1629 {
1630 struct rtl_priv *rtlpriv = btcoexist->adapter;
1631 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
1632 u8 ap_num = 0;
1633 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
1634 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1635
1636 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
1637 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
1638 tmp, 0);
1639 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
1640 coex_dm->switch_thres_offset - coex_dm->switch_thres_offset;
1641 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
1642
1643 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
1644
1645 /* office environment */
1646 if (BTC_RSSI_HIGH(wifi_rssi_state1) && (coex_sta->hid_exist) &&
1647 (coex_sta->a2dp_exist)) {
1648 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1649 "[BTCoex], Wifi idle process for BT HID+A2DP exist!!\n");
1650
1651 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x6);
1652 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1653
1654 /* sw all off */
1655 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1656 false);
1657 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1658 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1659 0x0, 0x0);
1660 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1661
1662 return true;
1663 }
1664
1665 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, true, 0x18);
1666 return false;
1667 }
1668
1669 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1670 {
1671 struct rtl_priv *rtlpriv = btcoexist->adapter;
1672 bool common = false, wifi_connected = false;
1673 bool wifi_busy = false;
1674 bool bt_hs_on = false, low_pwr_disable = false;
1675
1676 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1677 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1678 &wifi_connected);
1679 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1680
1681 if (!wifi_connected) {
1682 low_pwr_disable = false;
1683 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1684 &low_pwr_disable);
1685 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1686 false, false, 0x8);
1687
1688 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1689 "[BTCoex], Wifi non-connected idle!!\n");
1690
1691 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1692 0x0);
1693 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1694 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1695 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1696 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1697
1698 btc8723b2ant_sw_mechanism(btcoexist, false, false, false,
1699 false);
1700
1701 common = true;
1702 } else {
1703 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1704 coex_dm->bt_status) {
1705 low_pwr_disable = false;
1706 btcoexist->btc_set(btcoexist,
1707 BTC_SET_ACT_DISABLE_LOW_POWER,
1708 &low_pwr_disable);
1709 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1710 false, false, 0x8);
1711
1712 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1713 "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1714
1715 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1716 0xfffff, 0x0);
1717 btc8723b2ant_coex_table_with_type(btcoexist,
1718 NORMAL_EXEC, 0);
1719 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1720 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1721 0xb);
1722 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1723
1724 btc8723b2ant_sw_mechanism(btcoexist, false, false,
1725 false, false);
1726
1727 common = true;
1728 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1729 coex_dm->bt_status) {
1730 low_pwr_disable = true;
1731 btcoexist->btc_set(btcoexist,
1732 BTC_SET_ACT_DISABLE_LOW_POWER,
1733 &low_pwr_disable);
1734
1735 if (bt_hs_on)
1736 return false;
1737 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1738 "[BTCoex], Wifi connected + BT connected-idle!!\n");
1739 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC,
1740 false, false, 0x8);
1741
1742 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1743 0xfffff, 0x0);
1744 btc8723b2ant_coex_table_with_type(btcoexist,
1745 NORMAL_EXEC, 0);
1746 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1747 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1748 0xb);
1749 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
1750
1751 btc8723b2ant_sw_mechanism(btcoexist, true, false,
1752 false, false);
1753
1754 common = true;
1755 } else {
1756 low_pwr_disable = true;
1757 btcoexist->btc_set(btcoexist,
1758 BTC_SET_ACT_DISABLE_LOW_POWER,
1759 &low_pwr_disable);
1760
1761 if (wifi_busy) {
1762 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1763 "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1764 common = false;
1765 } else {
1766 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1767 "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1768
1769 common =
1770 btc8723b2ant_action_wifi_idle_process(
1771 btcoexist);
1772 }
1773 }
1774 }
1775
1776 return common;
1777 }
1778
1779 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
1780 bool sco_hid, bool tx_pause,
1781 u8 max_interval)
1782 {
1783 struct rtl_priv *rtlpriv = btcoexist->adapter;
1784 static s32 up, dn, m, n, wait_count;
1785 /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
1786 s32 result;
1787 u8 retry_count = 0;
1788
1789 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1790 "[BTCoex], TdmaDurationAdjust()\n");
1791
1792 if (!coex_dm->auto_tdma_adjust) {
1793 coex_dm->auto_tdma_adjust = true;
1794 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1795 "[BTCoex], first run TdmaDurationAdjust()!!\n");
1796 if (sco_hid) {
1797 if (tx_pause) {
1798 if (max_interval == 1) {
1799 btc8723b2ant_ps_tdma(btcoexist,
1800 NORMAL_EXEC,
1801 true, 13);
1802 coex_dm->ps_tdma_du_adj_type = 13;
1803 } else if (max_interval == 2) {
1804 btc8723b2ant_ps_tdma(btcoexist,
1805 NORMAL_EXEC,
1806 true, 14);
1807 coex_dm->ps_tdma_du_adj_type = 14;
1808 } else if (max_interval == 3) {
1809 btc8723b2ant_ps_tdma(btcoexist,
1810 NORMAL_EXEC,
1811 true, 15);
1812 coex_dm->ps_tdma_du_adj_type = 15;
1813 } else {
1814 btc8723b2ant_ps_tdma(btcoexist,
1815 NORMAL_EXEC,
1816 true, 15);
1817 coex_dm->ps_tdma_du_adj_type = 15;
1818 }
1819 } else {
1820 if (max_interval == 1) {
1821 btc8723b2ant_ps_tdma(btcoexist,
1822 NORMAL_EXEC,
1823 true, 9);
1824 coex_dm->ps_tdma_du_adj_type = 9;
1825 } else if (max_interval == 2) {
1826 btc8723b2ant_ps_tdma(btcoexist,
1827 NORMAL_EXEC,
1828 true, 10);
1829 coex_dm->ps_tdma_du_adj_type = 10;
1830 } else if (max_interval == 3) {
1831 btc8723b2ant_ps_tdma(btcoexist,
1832 NORMAL_EXEC,
1833 true, 11);
1834 coex_dm->ps_tdma_du_adj_type = 11;
1835 } else {
1836 btc8723b2ant_ps_tdma(btcoexist,
1837 NORMAL_EXEC,
1838 true, 11);
1839 coex_dm->ps_tdma_du_adj_type = 11;
1840 }
1841 }
1842 } else {
1843 if (tx_pause) {
1844 if (max_interval == 1) {
1845 btc8723b2ant_ps_tdma(btcoexist,
1846 NORMAL_EXEC,
1847 true, 5);
1848 coex_dm->ps_tdma_du_adj_type = 5;
1849 } else if (max_interval == 2) {
1850 btc8723b2ant_ps_tdma(btcoexist,
1851 NORMAL_EXEC,
1852 true, 6);
1853 coex_dm->ps_tdma_du_adj_type = 6;
1854 } else if (max_interval == 3) {
1855 btc8723b2ant_ps_tdma(btcoexist,
1856 NORMAL_EXEC,
1857 true, 7);
1858 coex_dm->ps_tdma_du_adj_type = 7;
1859 } else {
1860 btc8723b2ant_ps_tdma(btcoexist,
1861 NORMAL_EXEC,
1862 true, 7);
1863 coex_dm->ps_tdma_du_adj_type = 7;
1864 }
1865 } else {
1866 if (max_interval == 1) {
1867 btc8723b2ant_ps_tdma(btcoexist,
1868 NORMAL_EXEC,
1869 true, 1);
1870 coex_dm->ps_tdma_du_adj_type = 1;
1871 } else if (max_interval == 2) {
1872 btc8723b2ant_ps_tdma(btcoexist,
1873 NORMAL_EXEC,
1874 true, 2);
1875 coex_dm->ps_tdma_du_adj_type = 2;
1876 } else if (max_interval == 3) {
1877 btc8723b2ant_ps_tdma(btcoexist,
1878 NORMAL_EXEC,
1879 true, 3);
1880 coex_dm->ps_tdma_du_adj_type = 3;
1881 } else {
1882 btc8723b2ant_ps_tdma(btcoexist,
1883 NORMAL_EXEC,
1884 true, 3);
1885 coex_dm->ps_tdma_du_adj_type = 3;
1886 }
1887 }
1888 }
1889
1890 up = 0;
1891 dn = 0;
1892 m = 1;
1893 n = 3;
1894 result = 0;
1895 wait_count = 0;
1896 } else {
1897 /*accquire the BT TRx retry count from BT_Info byte2*/
1898 retry_count = coex_sta->bt_retry_cnt;
1899
1900 if ((coex_sta->low_priority_tx) > 1050 ||
1901 (coex_sta->low_priority_rx) > 1250)
1902 retry_count++;
1903
1904 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1905 "[BTCoex], retry_count = %d\n", retry_count);
1906 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1907 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
1908 up, dn, m, n, wait_count);
1909 result = 0;
1910 wait_count++;
1911 /* no retry in the last 2-second duration*/
1912 if (retry_count == 0) {
1913 up++;
1914 dn--;
1915
1916 if (dn <= 0)
1917 dn = 0;
1918
1919 if (up >= n) {
1920 /* if retry count during continuous n*2
1921 * seconds is 0, enlarge WiFi duration
1922 */
1923 wait_count = 0;
1924 n = 3;
1925 up = 0;
1926 dn = 0;
1927 result = 1;
1928 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1929 "[BTCoex], Increase wifi duration!!\n");
1930 } /* <=3 retry in the last 2-second duration*/
1931 } else if (retry_count <= 3) {
1932 up--;
1933 dn++;
1934
1935 if (up <= 0)
1936 up = 0;
1937
1938 if (dn == 2) {
1939 /* if continuous 2 retry count(every 2
1940 * seconds) >0 and < 3, reduce WiFi duration
1941 */
1942 if (wait_count <= 2)
1943 /* avoid loop between the two levels */
1944 m++;
1945 else
1946 m = 1;
1947
1948 if (m >= 20)
1949 /* maximum of m = 20 ' will recheck if
1950 * need to adjust wifi duration in
1951 * maximum time interval 120 seconds
1952 */
1953 m = 20;
1954
1955 n = 3 * m;
1956 up = 0;
1957 dn = 0;
1958 wait_count = 0;
1959 result = -1;
1960 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1961 "[BTCoex], Decrease wifi duration for retry_counter<3!!\n");
1962 }
1963 } else {
1964 /* retry count > 3, once retry count > 3, to reduce
1965 * WiFi duration
1966 */
1967 if (wait_count == 1)
1968 /* to avoid loop between the two levels */
1969 m++;
1970 else
1971 m = 1;
1972
1973 if (m >= 20)
1974 /* maximum of m = 20 ' will recheck if need to
1975 * adjust wifi duration in maximum time interval
1976 * 120 seconds
1977 */
1978 m = 20;
1979
1980 n = 3 * m;
1981 up = 0;
1982 dn = 0;
1983 wait_count = 0;
1984 result = -1;
1985 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1986 "[BTCoex], Decrease wifi duration for retry_counter>3!!\n");
1987 }
1988
1989 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1990 "[BTCoex], max Interval = %d\n", max_interval);
1991 if (max_interval == 1) {
1992 if (tx_pause) {
1993 if (coex_dm->cur_ps_tdma == 71) {
1994 btc8723b2ant_ps_tdma(btcoexist,
1995 NORMAL_EXEC,
1996 true, 5);
1997 coex_dm->ps_tdma_du_adj_type = 5;
1998 } else if (coex_dm->cur_ps_tdma == 1) {
1999 btc8723b2ant_ps_tdma(btcoexist,
2000 NORMAL_EXEC,
2001 true, 5);
2002 coex_dm->ps_tdma_du_adj_type = 5;
2003 } else if (coex_dm->cur_ps_tdma == 2) {
2004 btc8723b2ant_ps_tdma(btcoexist,
2005 NORMAL_EXEC,
2006 true, 6);
2007 coex_dm->ps_tdma_du_adj_type = 6;
2008 } else if (coex_dm->cur_ps_tdma == 3) {
2009 btc8723b2ant_ps_tdma(btcoexist,
2010 NORMAL_EXEC,
2011 true, 7);
2012 coex_dm->ps_tdma_du_adj_type = 7;
2013 } else if (coex_dm->cur_ps_tdma == 4) {
2014 btc8723b2ant_ps_tdma(btcoexist,
2015 NORMAL_EXEC,
2016 true, 8);
2017 coex_dm->ps_tdma_du_adj_type = 8;
2018 }
2019 if (coex_dm->cur_ps_tdma == 9) {
2020 btc8723b2ant_ps_tdma(btcoexist,
2021 NORMAL_EXEC,
2022 true, 13);
2023 coex_dm->ps_tdma_du_adj_type = 13;
2024 } else if (coex_dm->cur_ps_tdma == 10) {
2025 btc8723b2ant_ps_tdma(btcoexist,
2026 NORMAL_EXEC,
2027 true, 14);
2028 coex_dm->ps_tdma_du_adj_type = 14;
2029 } else if (coex_dm->cur_ps_tdma == 11) {
2030 btc8723b2ant_ps_tdma(btcoexist,
2031 NORMAL_EXEC,
2032 true, 15);
2033 coex_dm->ps_tdma_du_adj_type = 15;
2034 } else if (coex_dm->cur_ps_tdma == 12) {
2035 btc8723b2ant_ps_tdma(btcoexist,
2036 NORMAL_EXEC,
2037 true, 16);
2038 coex_dm->ps_tdma_du_adj_type = 16;
2039 }
2040
2041 if (result == -1) {
2042 if (coex_dm->cur_ps_tdma == 5) {
2043 btc8723b2ant_ps_tdma(
2044 btcoexist, NORMAL_EXEC,
2045 true, 6);
2046 coex_dm->ps_tdma_du_adj_type =
2047 6;
2048 } else if (coex_dm->cur_ps_tdma == 6) {
2049 btc8723b2ant_ps_tdma(
2050 btcoexist, NORMAL_EXEC,
2051 true, 7);
2052 coex_dm->ps_tdma_du_adj_type =
2053 7;
2054 } else if (coex_dm->cur_ps_tdma == 7) {
2055 btc8723b2ant_ps_tdma(
2056 btcoexist, NORMAL_EXEC,
2057 true, 8);
2058 coex_dm->ps_tdma_du_adj_type =
2059 8;
2060 } else if (coex_dm->cur_ps_tdma == 13) {
2061 btc8723b2ant_ps_tdma(
2062 btcoexist, NORMAL_EXEC,
2063 true, 14);
2064 coex_dm->ps_tdma_du_adj_type =
2065 14;
2066 } else if (coex_dm->cur_ps_tdma == 14) {
2067 btc8723b2ant_ps_tdma(
2068 btcoexist, NORMAL_EXEC,
2069 true, 15);
2070 coex_dm->ps_tdma_du_adj_type =
2071 15;
2072 } else if (coex_dm->cur_ps_tdma == 15) {
2073 btc8723b2ant_ps_tdma(
2074 btcoexist, NORMAL_EXEC,
2075 true, 16);
2076 coex_dm->ps_tdma_du_adj_type =
2077 16;
2078 }
2079 } else if (result == 1) {
2080 if (coex_dm->cur_ps_tdma == 8) {
2081 btc8723b2ant_ps_tdma(
2082 btcoexist, NORMAL_EXEC,
2083 true, 7);
2084 coex_dm->ps_tdma_du_adj_type =
2085 7;
2086 } else if (coex_dm->cur_ps_tdma == 7) {
2087 btc8723b2ant_ps_tdma(
2088 btcoexist, NORMAL_EXEC,
2089 true, 6);
2090 coex_dm->ps_tdma_du_adj_type =
2091 6;
2092 } else if (coex_dm->cur_ps_tdma == 6) {
2093 btc8723b2ant_ps_tdma(
2094 btcoexist, NORMAL_EXEC,
2095 true, 5);
2096 coex_dm->ps_tdma_du_adj_type =
2097 5;
2098 } else if (coex_dm->cur_ps_tdma == 16) {
2099 btc8723b2ant_ps_tdma(
2100 btcoexist, NORMAL_EXEC,
2101 true, 15);
2102 coex_dm->ps_tdma_du_adj_type =
2103 15;
2104 } else if (coex_dm->cur_ps_tdma == 15) {
2105 btc8723b2ant_ps_tdma(
2106 btcoexist, NORMAL_EXEC,
2107 true, 14);
2108 coex_dm->ps_tdma_du_adj_type =
2109 14;
2110 } else if (coex_dm->cur_ps_tdma == 14) {
2111 btc8723b2ant_ps_tdma(
2112 btcoexist, NORMAL_EXEC,
2113 true, 13);
2114 coex_dm->ps_tdma_du_adj_type =
2115 13;
2116 }
2117 }
2118 } else {
2119 if (coex_dm->cur_ps_tdma == 5) {
2120 btc8723b2ant_ps_tdma(btcoexist,
2121 NORMAL_EXEC,
2122 true, 71);
2123 coex_dm->ps_tdma_du_adj_type = 71;
2124 } else if (coex_dm->cur_ps_tdma == 6) {
2125 btc8723b2ant_ps_tdma(btcoexist,
2126 NORMAL_EXEC,
2127 true, 2);
2128 coex_dm->ps_tdma_du_adj_type = 2;
2129 } else if (coex_dm->cur_ps_tdma == 7) {
2130 btc8723b2ant_ps_tdma(btcoexist,
2131 NORMAL_EXEC,
2132 true, 3);
2133 coex_dm->ps_tdma_du_adj_type = 3;
2134 } else if (coex_dm->cur_ps_tdma == 8) {
2135 btc8723b2ant_ps_tdma(btcoexist,
2136 NORMAL_EXEC,
2137 true, 4);
2138 coex_dm->ps_tdma_du_adj_type = 4;
2139 }
2140 if (coex_dm->cur_ps_tdma == 13) {
2141 btc8723b2ant_ps_tdma(btcoexist,
2142 NORMAL_EXEC,
2143 true, 9);
2144 coex_dm->ps_tdma_du_adj_type = 9;
2145 } else if (coex_dm->cur_ps_tdma == 14) {
2146 btc8723b2ant_ps_tdma(btcoexist,
2147 NORMAL_EXEC,
2148 true, 10);
2149 coex_dm->ps_tdma_du_adj_type = 10;
2150 } else if (coex_dm->cur_ps_tdma == 15) {
2151 btc8723b2ant_ps_tdma(btcoexist,
2152 NORMAL_EXEC,
2153 true, 11);
2154 coex_dm->ps_tdma_du_adj_type = 11;
2155 } else if (coex_dm->cur_ps_tdma == 16) {
2156 btc8723b2ant_ps_tdma(btcoexist,
2157 NORMAL_EXEC,
2158 true, 12);
2159 coex_dm->ps_tdma_du_adj_type = 12;
2160 }
2161
2162 if (result == -1) {
2163 if (coex_dm->cur_ps_tdma == 71) {
2164 btc8723b2ant_ps_tdma(
2165 btcoexist, NORMAL_EXEC,
2166 true, 1);
2167 coex_dm->ps_tdma_du_adj_type =
2168 1;
2169 } else if (coex_dm->cur_ps_tdma == 1) {
2170 btc8723b2ant_ps_tdma(
2171 btcoexist, NORMAL_EXEC,
2172 true, 2);
2173 coex_dm->ps_tdma_du_adj_type =
2174 2;
2175 } else if (coex_dm->cur_ps_tdma == 2) {
2176 btc8723b2ant_ps_tdma(
2177 btcoexist, NORMAL_EXEC,
2178 true, 3);
2179 coex_dm->ps_tdma_du_adj_type =
2180 3;
2181 } else if (coex_dm->cur_ps_tdma == 3) {
2182 btc8723b2ant_ps_tdma(
2183 btcoexist, NORMAL_EXEC,
2184 true, 4);
2185 coex_dm->ps_tdma_du_adj_type =
2186 4;
2187 } else if (coex_dm->cur_ps_tdma == 9) {
2188 btc8723b2ant_ps_tdma(
2189 btcoexist, NORMAL_EXEC,
2190 true, 10);
2191 coex_dm->ps_tdma_du_adj_type =
2192 10;
2193 } else if (coex_dm->cur_ps_tdma == 10) {
2194 btc8723b2ant_ps_tdma(
2195 btcoexist, NORMAL_EXEC,
2196 true, 11);
2197 coex_dm->ps_tdma_du_adj_type =
2198 11;
2199 } else if (coex_dm->cur_ps_tdma == 11) {
2200 btc8723b2ant_ps_tdma(
2201 btcoexist, NORMAL_EXEC,
2202 true, 12);
2203 coex_dm->ps_tdma_du_adj_type =
2204 12;
2205 }
2206 } else if (result == 1) {
2207 if (coex_dm->cur_ps_tdma == 4) {
2208 btc8723b2ant_ps_tdma(
2209 btcoexist, NORMAL_EXEC,
2210 true, 3);
2211 coex_dm->ps_tdma_du_adj_type =
2212 3;
2213 } else if (coex_dm->cur_ps_tdma == 3) {
2214 btc8723b2ant_ps_tdma(
2215 btcoexist, NORMAL_EXEC,
2216 true, 2);
2217 coex_dm->ps_tdma_du_adj_type =
2218 2;
2219 } else if (coex_dm->cur_ps_tdma == 2) {
2220 btc8723b2ant_ps_tdma(
2221 btcoexist, NORMAL_EXEC,
2222 true, 1);
2223 coex_dm->ps_tdma_du_adj_type =
2224 1;
2225 } else if (coex_dm->cur_ps_tdma == 1) {
2226 btc8723b2ant_ps_tdma(
2227 btcoexist, NORMAL_EXEC,
2228 true, 71);
2229 coex_dm->ps_tdma_du_adj_type =
2230 71;
2231 } else if (coex_dm->cur_ps_tdma == 12) {
2232 btc8723b2ant_ps_tdma(
2233 btcoexist, NORMAL_EXEC,
2234 true, 11);
2235 coex_dm->ps_tdma_du_adj_type =
2236 11;
2237 } else if (coex_dm->cur_ps_tdma == 11) {
2238 btc8723b2ant_ps_tdma(
2239 btcoexist, NORMAL_EXEC,
2240 true, 10);
2241 coex_dm->ps_tdma_du_adj_type =
2242 10;
2243 } else if (coex_dm->cur_ps_tdma == 10) {
2244 btc8723b2ant_ps_tdma(
2245 btcoexist, NORMAL_EXEC,
2246 true, 9);
2247 coex_dm->ps_tdma_du_adj_type =
2248 9;
2249 }
2250 }
2251 }
2252 } else if (max_interval == 2) {
2253 if (tx_pause) {
2254 if (coex_dm->cur_ps_tdma == 1) {
2255 btc8723b2ant_ps_tdma(btcoexist,
2256 NORMAL_EXEC,
2257 true, 6);
2258 coex_dm->ps_tdma_du_adj_type = 6;
2259 } else if (coex_dm->cur_ps_tdma == 2) {
2260 btc8723b2ant_ps_tdma(btcoexist,
2261 NORMAL_EXEC,
2262 true, 6);
2263 coex_dm->ps_tdma_du_adj_type = 6;
2264 } else if (coex_dm->cur_ps_tdma == 3) {
2265 btc8723b2ant_ps_tdma(btcoexist,
2266 NORMAL_EXEC,
2267 true, 7);
2268 coex_dm->ps_tdma_du_adj_type = 7;
2269 } else if (coex_dm->cur_ps_tdma == 4) {
2270 btc8723b2ant_ps_tdma(btcoexist,
2271 NORMAL_EXEC,
2272 true, 8);
2273 coex_dm->ps_tdma_du_adj_type = 8;
2274 }
2275 if (coex_dm->cur_ps_tdma == 9) {
2276 btc8723b2ant_ps_tdma(btcoexist,
2277 NORMAL_EXEC,
2278 true, 14);
2279 coex_dm->ps_tdma_du_adj_type = 14;
2280 } else if (coex_dm->cur_ps_tdma == 10) {
2281 btc8723b2ant_ps_tdma(btcoexist,
2282 NORMAL_EXEC,
2283 true, 14);
2284 coex_dm->ps_tdma_du_adj_type = 14;
2285 } else if (coex_dm->cur_ps_tdma == 11) {
2286 btc8723b2ant_ps_tdma(btcoexist,
2287 NORMAL_EXEC,
2288 true, 15);
2289 coex_dm->ps_tdma_du_adj_type = 15;
2290 } else if (coex_dm->cur_ps_tdma == 12) {
2291 btc8723b2ant_ps_tdma(btcoexist,
2292 NORMAL_EXEC,
2293 true, 16);
2294 coex_dm->ps_tdma_du_adj_type = 16;
2295 }
2296 if (result == -1) {
2297 if (coex_dm->cur_ps_tdma == 5) {
2298 btc8723b2ant_ps_tdma(
2299 btcoexist, NORMAL_EXEC,
2300 true, 6);
2301 coex_dm->ps_tdma_du_adj_type =
2302 6;
2303 } else if (coex_dm->cur_ps_tdma == 6) {
2304 btc8723b2ant_ps_tdma(
2305 btcoexist, NORMAL_EXEC,
2306 true, 7);
2307 coex_dm->ps_tdma_du_adj_type =
2308 7;
2309 } else if (coex_dm->cur_ps_tdma == 7) {
2310 btc8723b2ant_ps_tdma(
2311 btcoexist, NORMAL_EXEC,
2312 true, 8);
2313 coex_dm->ps_tdma_du_adj_type =
2314 8;
2315 } else if (coex_dm->cur_ps_tdma == 13) {
2316 btc8723b2ant_ps_tdma(
2317 btcoexist, NORMAL_EXEC,
2318 true, 14);
2319 coex_dm->ps_tdma_du_adj_type =
2320 14;
2321 } else if (coex_dm->cur_ps_tdma == 14) {
2322 btc8723b2ant_ps_tdma(
2323 btcoexist, NORMAL_EXEC,
2324 true, 15);
2325 coex_dm->ps_tdma_du_adj_type =
2326 15;
2327 } else if (coex_dm->cur_ps_tdma == 15) {
2328 btc8723b2ant_ps_tdma(
2329 btcoexist, NORMAL_EXEC,
2330 true, 16);
2331 coex_dm->ps_tdma_du_adj_type =
2332 16;
2333 }
2334 } else if (result == 1) {
2335 if (coex_dm->cur_ps_tdma == 8) {
2336 btc8723b2ant_ps_tdma(
2337 btcoexist, NORMAL_EXEC,
2338 true, 7);
2339 coex_dm->ps_tdma_du_adj_type =
2340 7;
2341 } else if (coex_dm->cur_ps_tdma == 7) {
2342 btc8723b2ant_ps_tdma(
2343 btcoexist, NORMAL_EXEC,
2344 true, 6);
2345 coex_dm->ps_tdma_du_adj_type =
2346 6;
2347 } else if (coex_dm->cur_ps_tdma == 6) {
2348 btc8723b2ant_ps_tdma(
2349 btcoexist, NORMAL_EXEC,
2350 true, 6);
2351 coex_dm->ps_tdma_du_adj_type =
2352 6;
2353 } else if (coex_dm->cur_ps_tdma == 16) {
2354 btc8723b2ant_ps_tdma(
2355 btcoexist, NORMAL_EXEC,
2356 true, 15);
2357 coex_dm->ps_tdma_du_adj_type =
2358 15;
2359 } else if (coex_dm->cur_ps_tdma == 15) {
2360 btc8723b2ant_ps_tdma(
2361 btcoexist, NORMAL_EXEC,
2362 true, 14);
2363 coex_dm->ps_tdma_du_adj_type =
2364 14;
2365 } else if (coex_dm->cur_ps_tdma == 14) {
2366 btc8723b2ant_ps_tdma(
2367 btcoexist, NORMAL_EXEC,
2368 true, 14);
2369 coex_dm->ps_tdma_du_adj_type =
2370 14;
2371 }
2372 }
2373 } else {
2374 if (coex_dm->cur_ps_tdma == 5) {
2375 btc8723b2ant_ps_tdma(btcoexist,
2376 NORMAL_EXEC,
2377 true, 2);
2378 coex_dm->ps_tdma_du_adj_type = 2;
2379 } else if (coex_dm->cur_ps_tdma == 6) {
2380 btc8723b2ant_ps_tdma(btcoexist,
2381 NORMAL_EXEC,
2382 true, 2);
2383 coex_dm->ps_tdma_du_adj_type = 2;
2384 } else if (coex_dm->cur_ps_tdma == 7) {
2385 btc8723b2ant_ps_tdma(btcoexist,
2386 NORMAL_EXEC,
2387 true, 3);
2388 coex_dm->ps_tdma_du_adj_type = 3;
2389 } else if (coex_dm->cur_ps_tdma == 8) {
2390 btc8723b2ant_ps_tdma(btcoexist,
2391 NORMAL_EXEC,
2392 true, 4);
2393 coex_dm->ps_tdma_du_adj_type = 4;
2394 }
2395 if (coex_dm->cur_ps_tdma == 13) {
2396 btc8723b2ant_ps_tdma(btcoexist,
2397 NORMAL_EXEC,
2398 true, 10);
2399 coex_dm->ps_tdma_du_adj_type = 10;
2400 } else if (coex_dm->cur_ps_tdma == 14) {
2401 btc8723b2ant_ps_tdma(btcoexist,
2402 NORMAL_EXEC,
2403 true, 10);
2404 coex_dm->ps_tdma_du_adj_type = 10;
2405 } else if (coex_dm->cur_ps_tdma == 15) {
2406 btc8723b2ant_ps_tdma(btcoexist,
2407 NORMAL_EXEC,
2408 true, 11);
2409 coex_dm->ps_tdma_du_adj_type = 11;
2410 } else if (coex_dm->cur_ps_tdma == 16) {
2411 btc8723b2ant_ps_tdma(btcoexist,
2412 NORMAL_EXEC,
2413 true, 12);
2414 coex_dm->ps_tdma_du_adj_type = 12;
2415 }
2416 if (result == -1) {
2417 if (coex_dm->cur_ps_tdma == 1) {
2418 btc8723b2ant_ps_tdma(
2419 btcoexist, NORMAL_EXEC,
2420 true, 2);
2421 coex_dm->ps_tdma_du_adj_type =
2422 2;
2423 } else if (coex_dm->cur_ps_tdma == 2) {
2424 btc8723b2ant_ps_tdma(
2425 btcoexist, NORMAL_EXEC,
2426 true, 3);
2427 coex_dm->ps_tdma_du_adj_type =
2428 3;
2429 } else if (coex_dm->cur_ps_tdma == 3) {
2430 btc8723b2ant_ps_tdma(
2431 btcoexist, NORMAL_EXEC,
2432 true, 4);
2433 coex_dm->ps_tdma_du_adj_type =
2434 4;
2435 } else if (coex_dm->cur_ps_tdma == 9) {
2436 btc8723b2ant_ps_tdma(
2437 btcoexist, NORMAL_EXEC,
2438 true, 10);
2439 coex_dm->ps_tdma_du_adj_type =
2440 10;
2441 } else if (coex_dm->cur_ps_tdma == 10) {
2442 btc8723b2ant_ps_tdma(
2443 btcoexist, NORMAL_EXEC,
2444 true, 11);
2445 coex_dm->ps_tdma_du_adj_type =
2446 11;
2447 } else if (coex_dm->cur_ps_tdma == 11) {
2448 btc8723b2ant_ps_tdma(
2449 btcoexist, NORMAL_EXEC,
2450 true, 12);
2451 coex_dm->ps_tdma_du_adj_type =
2452 12;
2453 }
2454 } else if (result == 1) {
2455 if (coex_dm->cur_ps_tdma == 4) {
2456 btc8723b2ant_ps_tdma(
2457 btcoexist, NORMAL_EXEC,
2458 true, 3);
2459 coex_dm->ps_tdma_du_adj_type =
2460 3;
2461 } else if (coex_dm->cur_ps_tdma == 3) {
2462 btc8723b2ant_ps_tdma(
2463 btcoexist, NORMAL_EXEC,
2464 true, 2);
2465 coex_dm->ps_tdma_du_adj_type =
2466 2;
2467 } else if (coex_dm->cur_ps_tdma == 2) {
2468 btc8723b2ant_ps_tdma(
2469 btcoexist, NORMAL_EXEC,
2470 true, 2);
2471 coex_dm->ps_tdma_du_adj_type =
2472 2;
2473 } else if (coex_dm->cur_ps_tdma == 12) {
2474 btc8723b2ant_ps_tdma(
2475 btcoexist, NORMAL_EXEC,
2476 true, 11);
2477 coex_dm->ps_tdma_du_adj_type =
2478 11;
2479 } else if (coex_dm->cur_ps_tdma == 11) {
2480 btc8723b2ant_ps_tdma(
2481 btcoexist, NORMAL_EXEC,
2482 true, 10);
2483 coex_dm->ps_tdma_du_adj_type =
2484 10;
2485 } else if (coex_dm->cur_ps_tdma == 10) {
2486 btc8723b2ant_ps_tdma(
2487 btcoexist, NORMAL_EXEC,
2488 true, 10);
2489 coex_dm->ps_tdma_du_adj_type =
2490 10;
2491 }
2492 }
2493 }
2494 } else if (max_interval == 3) {
2495 if (tx_pause) {
2496 if (coex_dm->cur_ps_tdma == 1) {
2497 btc8723b2ant_ps_tdma(btcoexist,
2498 NORMAL_EXEC,
2499 true, 7);
2500 coex_dm->ps_tdma_du_adj_type = 7;
2501 } else if (coex_dm->cur_ps_tdma == 2) {
2502 btc8723b2ant_ps_tdma(btcoexist,
2503 NORMAL_EXEC,
2504 true, 7);
2505 coex_dm->ps_tdma_du_adj_type = 7;
2506 } else if (coex_dm->cur_ps_tdma == 3) {
2507 btc8723b2ant_ps_tdma(btcoexist,
2508 NORMAL_EXEC,
2509 true, 7);
2510 coex_dm->ps_tdma_du_adj_type = 7;
2511 } else if (coex_dm->cur_ps_tdma == 4) {
2512 btc8723b2ant_ps_tdma(btcoexist,
2513 NORMAL_EXEC,
2514 true, 8);
2515 coex_dm->ps_tdma_du_adj_type = 8;
2516 }
2517 if (coex_dm->cur_ps_tdma == 9) {
2518 btc8723b2ant_ps_tdma(btcoexist,
2519 NORMAL_EXEC,
2520 true, 15);
2521 coex_dm->ps_tdma_du_adj_type = 15;
2522 } else if (coex_dm->cur_ps_tdma == 10) {
2523 btc8723b2ant_ps_tdma(btcoexist,
2524 NORMAL_EXEC,
2525 true, 15);
2526 coex_dm->ps_tdma_du_adj_type = 15;
2527 } else if (coex_dm->cur_ps_tdma == 11) {
2528 btc8723b2ant_ps_tdma(btcoexist,
2529 NORMAL_EXEC,
2530 true, 15);
2531 coex_dm->ps_tdma_du_adj_type = 15;
2532 } else if (coex_dm->cur_ps_tdma == 12) {
2533 btc8723b2ant_ps_tdma(btcoexist,
2534 NORMAL_EXEC,
2535 true, 16);
2536 coex_dm->ps_tdma_du_adj_type = 16;
2537 }
2538 if (result == -1) {
2539 if (coex_dm->cur_ps_tdma == 5) {
2540 btc8723b2ant_ps_tdma(
2541 btcoexist, NORMAL_EXEC,
2542 true, 7);
2543 coex_dm->ps_tdma_du_adj_type =
2544 7;
2545 } else if (coex_dm->cur_ps_tdma == 6) {
2546 btc8723b2ant_ps_tdma(
2547 btcoexist, NORMAL_EXEC,
2548 true, 7);
2549 coex_dm->ps_tdma_du_adj_type =
2550 7;
2551 } else if (coex_dm->cur_ps_tdma == 7) {
2552 btc8723b2ant_ps_tdma(
2553 btcoexist, NORMAL_EXEC,
2554 true, 8);
2555 coex_dm->ps_tdma_du_adj_type =
2556 8;
2557 } else if (coex_dm->cur_ps_tdma == 13) {
2558 btc8723b2ant_ps_tdma(
2559 btcoexist, NORMAL_EXEC,
2560 true, 15);
2561 coex_dm->ps_tdma_du_adj_type =
2562 15;
2563 } else if (coex_dm->cur_ps_tdma == 14) {
2564 btc8723b2ant_ps_tdma(
2565 btcoexist, NORMAL_EXEC,
2566 true, 15);
2567 coex_dm->ps_tdma_du_adj_type =
2568 15;
2569 } else if (coex_dm->cur_ps_tdma == 15) {
2570 btc8723b2ant_ps_tdma(
2571 btcoexist, NORMAL_EXEC,
2572 true, 16);
2573 coex_dm->ps_tdma_du_adj_type =
2574 16;
2575 }
2576 } else if (result == 1) {
2577 if (coex_dm->cur_ps_tdma == 8) {
2578 btc8723b2ant_ps_tdma(
2579 btcoexist, NORMAL_EXEC,
2580 true, 7);
2581 coex_dm->ps_tdma_du_adj_type =
2582 7;
2583 } else if (coex_dm->cur_ps_tdma == 7) {
2584 btc8723b2ant_ps_tdma(
2585 btcoexist, NORMAL_EXEC,
2586 true, 7);
2587 coex_dm->ps_tdma_du_adj_type =
2588 7;
2589 } else if (coex_dm->cur_ps_tdma == 6) {
2590 btc8723b2ant_ps_tdma(
2591 btcoexist, NORMAL_EXEC,
2592 true, 7);
2593 coex_dm->ps_tdma_du_adj_type =
2594 7;
2595 } else if (coex_dm->cur_ps_tdma == 16) {
2596 btc8723b2ant_ps_tdma(
2597 btcoexist, NORMAL_EXEC,
2598 true, 15);
2599 coex_dm->ps_tdma_du_adj_type =
2600 15;
2601 } else if (coex_dm->cur_ps_tdma == 15) {
2602 btc8723b2ant_ps_tdma(
2603 btcoexist, NORMAL_EXEC,
2604 true, 15);
2605 coex_dm->ps_tdma_du_adj_type =
2606 15;
2607 } else if (coex_dm->cur_ps_tdma == 14) {
2608 btc8723b2ant_ps_tdma(
2609 btcoexist, NORMAL_EXEC,
2610 true, 15);
2611 coex_dm->ps_tdma_du_adj_type =
2612 15;
2613 }
2614 }
2615 } else {
2616 if (coex_dm->cur_ps_tdma == 5) {
2617 btc8723b2ant_ps_tdma(btcoexist,
2618 NORMAL_EXEC,
2619 true, 3);
2620 coex_dm->ps_tdma_du_adj_type = 3;
2621 } else if (coex_dm->cur_ps_tdma == 6) {
2622 btc8723b2ant_ps_tdma(btcoexist,
2623 NORMAL_EXEC,
2624 true, 3);
2625 coex_dm->ps_tdma_du_adj_type = 3;
2626 } else if (coex_dm->cur_ps_tdma == 7) {
2627 btc8723b2ant_ps_tdma(btcoexist,
2628 NORMAL_EXEC,
2629 true, 3);
2630 coex_dm->ps_tdma_du_adj_type = 3;
2631 } else if (coex_dm->cur_ps_tdma == 8) {
2632 btc8723b2ant_ps_tdma(btcoexist,
2633 NORMAL_EXEC,
2634 true, 4);
2635 coex_dm->ps_tdma_du_adj_type = 4;
2636 }
2637 if (coex_dm->cur_ps_tdma == 13) {
2638 btc8723b2ant_ps_tdma(btcoexist,
2639 NORMAL_EXEC,
2640 true, 11);
2641 coex_dm->ps_tdma_du_adj_type = 11;
2642 } else if (coex_dm->cur_ps_tdma == 14) {
2643 btc8723b2ant_ps_tdma(btcoexist,
2644 NORMAL_EXEC,
2645 true, 11);
2646 coex_dm->ps_tdma_du_adj_type = 11;
2647 } else if (coex_dm->cur_ps_tdma == 15) {
2648 btc8723b2ant_ps_tdma(btcoexist,
2649 NORMAL_EXEC,
2650 true, 11);
2651 coex_dm->ps_tdma_du_adj_type = 11;
2652 } else if (coex_dm->cur_ps_tdma == 16) {
2653 btc8723b2ant_ps_tdma(btcoexist,
2654 NORMAL_EXEC,
2655 true, 12);
2656 coex_dm->ps_tdma_du_adj_type = 12;
2657 }
2658 if (result == -1) {
2659 if (coex_dm->cur_ps_tdma == 1) {
2660 btc8723b2ant_ps_tdma(
2661 btcoexist, NORMAL_EXEC,
2662 true, 3);
2663 coex_dm->ps_tdma_du_adj_type =
2664 3;
2665 } else if (coex_dm->cur_ps_tdma == 2) {
2666 btc8723b2ant_ps_tdma(
2667 btcoexist, NORMAL_EXEC,
2668 true, 3);
2669 coex_dm->ps_tdma_du_adj_type =
2670 3;
2671 } else if (coex_dm->cur_ps_tdma == 3) {
2672 btc8723b2ant_ps_tdma(
2673 btcoexist, NORMAL_EXEC,
2674 true, 4);
2675 coex_dm->ps_tdma_du_adj_type =
2676 4;
2677 } else if (coex_dm->cur_ps_tdma == 9) {
2678 btc8723b2ant_ps_tdma(
2679 btcoexist, NORMAL_EXEC,
2680 true, 11);
2681 coex_dm->ps_tdma_du_adj_type =
2682 11;
2683 } else if (coex_dm->cur_ps_tdma == 10) {
2684 btc8723b2ant_ps_tdma(
2685 btcoexist, NORMAL_EXEC,
2686 true, 11);
2687 coex_dm->ps_tdma_du_adj_type =
2688 11;
2689 } else if (coex_dm->cur_ps_tdma == 11) {
2690 btc8723b2ant_ps_tdma(
2691 btcoexist, NORMAL_EXEC,
2692 true, 12);
2693 coex_dm->ps_tdma_du_adj_type =
2694 12;
2695 }
2696 } else if (result == 1) {
2697 if (coex_dm->cur_ps_tdma == 4) {
2698 btc8723b2ant_ps_tdma(
2699 btcoexist, NORMAL_EXEC,
2700 true, 3);
2701 coex_dm->ps_tdma_du_adj_type =
2702 3;
2703 } else if (coex_dm->cur_ps_tdma == 3) {
2704 btc8723b2ant_ps_tdma(
2705 btcoexist, NORMAL_EXEC,
2706 true, 3);
2707 coex_dm->ps_tdma_du_adj_type =
2708 3;
2709 } else if (coex_dm->cur_ps_tdma == 2) {
2710 btc8723b2ant_ps_tdma(
2711 btcoexist, NORMAL_EXEC,
2712 true, 3);
2713 coex_dm->ps_tdma_du_adj_type =
2714 3;
2715 } else if (coex_dm->cur_ps_tdma == 12) {
2716 btc8723b2ant_ps_tdma(
2717 btcoexist, NORMAL_EXEC,
2718 true, 11);
2719 coex_dm->ps_tdma_du_adj_type =
2720 11;
2721 } else if (coex_dm->cur_ps_tdma == 11) {
2722 btc8723b2ant_ps_tdma(
2723 btcoexist, NORMAL_EXEC,
2724 true, 11);
2725 coex_dm->ps_tdma_du_adj_type =
2726 11;
2727 } else if (coex_dm->cur_ps_tdma == 10) {
2728 btc8723b2ant_ps_tdma(
2729 btcoexist, NORMAL_EXEC,
2730 true, 11);
2731 coex_dm->ps_tdma_du_adj_type =
2732 11;
2733 }
2734 }
2735 }
2736 }
2737 }
2738
2739 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2740 "[BTCoex], max Interval = %d\n", max_interval);
2741
2742 /* if current PsTdma not match with the recorded one (scan, dhcp, ...),
2743 * then we have to adjust it back to the previous recorded one.
2744 */
2745 if (coex_dm->cur_ps_tdma != coex_dm->ps_tdma_du_adj_type) {
2746 bool scan = false, link = false, roam = false;
2747 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2748 "[BTCoex], PsTdma type mismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
2749 coex_dm->cur_ps_tdma, coex_dm->ps_tdma_du_adj_type);
2750
2751 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2752 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2753 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2754
2755 if (!scan && !link && !roam)
2756 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2757 coex_dm->ps_tdma_du_adj_type);
2758 else
2759 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2760 "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2761 }
2762 }
2763
2764 /* SCO only or SCO+PAN(HS) */
2765 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2766 {
2767 u8 wifi_rssi_state, bt_rssi_state;
2768 u32 wifi_bw;
2769
2770 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2771 bt_rssi_state = btc8723b2ant_bt_rssi_state(
2772 btcoexist, 2, BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2773 coex_dm->switch_thres_offset,
2774 0);
2775
2776 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2777
2778 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2779 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2780
2781 if (BTC_RSSI_HIGH(bt_rssi_state))
2782 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2783 else
2784 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2785
2786 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2787
2788 if (BTC_WIFI_BW_LEGACY == wifi_bw)
2789 /* for SCO quality at 11b/g mode */
2790 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2791 else
2792 /* for SCO quality & wifi performance balance at 11n mode */
2793 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2794
2795 /* for voice quality */
2796 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2797
2798 /* sw mechanism */
2799 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2800 btc8723b2ant_sw_mechanism(btcoexist, true, true,
2801 false, false);
2802 } else {
2803 btc8723b2ant_sw_mechanism(btcoexist, false, true,
2804 false, false);
2805 }
2806 }
2807
2808 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2809 {
2810 u8 wifi_rssi_state, bt_rssi_state;
2811 u32 wifi_bw;
2812 u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2813 coex_dm->switch_thres_offset;
2814
2815 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2816 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2817
2818 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2819
2820 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2821 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2822
2823 if (BTC_RSSI_HIGH(bt_rssi_state))
2824 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2825 else
2826 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2827
2828 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2829
2830 if (wifi_bw == BTC_WIFI_BW_LEGACY)
2831 /* for HID at 11b/g mode */
2832 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2833 else
2834 /* for HID quality & wifi performance balance at 11n mode */
2835 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 9);
2836
2837 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2838
2839 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2840 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2841 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2842 else
2843 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2844
2845 /* sw mechanism */
2846 if (wifi_bw == BTC_WIFI_BW_HT40)
2847 btc8723b2ant_sw_mechanism(btcoexist, true, true, false, false);
2848 else
2849 btc8723b2ant_sw_mechanism(btcoexist, false, true, false, false);
2850 }
2851
2852 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2853 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2854 {
2855 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2856 u32 wifi_bw;
2857 u8 ap_num = 0;
2858 u8 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2859 coex_dm->switch_thres_offset;
2860
2861 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2862 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2, 40, 0);
2863 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2864
2865 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
2866
2867 /* define the office environment */
2868 /* driver don't know AP num in Linux, so we will never enter this if */
2869 if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) {
2870 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2871 0x0);
2872 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2873 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2874 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2875 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2876
2877 /* sw mechanism */
2878 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2879 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2880 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2881 false, false);
2882 } else {
2883 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2884 false, false);
2885 }
2886 return;
2887 }
2888
2889 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2890 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2891
2892 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2893
2894 if (BTC_RSSI_HIGH(bt_rssi_state))
2895 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2896 else
2897 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2898
2899 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2900 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2901 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2902 0x0, 0x0);
2903 } else {
2904 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2905 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2906 0x4);
2907 }
2908
2909 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2910 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2911 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2912 false, 1);
2913 else
2914 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2915
2916 /* sw mechanism */
2917 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2918 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2919 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2920 false, false);
2921 } else {
2922 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2923 false, false);
2924 }
2925 }
2926
2927 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2928 {
2929 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2930 u32 wifi_bw;
2931 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
2932 coex_dm->switch_thres_offset;
2933
2934 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2935 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
2936 tmp, 0);
2937 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2938 coex_dm->switch_thres_offset;
2939 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2940
2941 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2942
2943 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2944 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2945
2946 if (BTC_RSSI_HIGH(bt_rssi_state))
2947 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2948 else
2949 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2950
2951 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2952 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
2953 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2954 0x0, 0x0);
2955 } else {
2956 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
2957 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
2958 0x4);
2959 }
2960
2961 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2962
2963 /* sw mechanism */
2964 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2965 if (BTC_WIFI_BW_HT40 == wifi_bw) {
2966 btc8723b2ant_sw_mechanism(btcoexist, true, false,
2967 false, false);
2968 } else {
2969 btc8723b2ant_sw_mechanism(btcoexist, false, false,
2970 false, false);
2971 }
2972 }
2973
2974 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
2975 {
2976 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
2977 u32 wifi_bw;
2978 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
2979 coex_dm->switch_thres_offset;
2980
2981 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
2982 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
2983 tmp, 0);
2984 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
2985 coex_dm->switch_thres_offset;
2986 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
2987
2988 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2989
2990 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
2991 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2992
2993 if (BTC_RSSI_HIGH(bt_rssi_state))
2994 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2995 else
2996 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2997
2998 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
2999 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 10);
3000 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3001 0x0, 0x0);
3002 } else {
3003 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 13);
3004 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3005 0x4);
3006 }
3007
3008 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3009 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
3010 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
3011 else
3012 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
3013
3014 /* sw mechanism */
3015 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3016 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3017 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3018 false, false);
3019 } else {
3020 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3021 false, false);
3022 }
3023 }
3024
3025 /* PAN(HS) only */
3026 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
3027 {
3028 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3029 u32 wifi_bw;
3030 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3031 coex_dm->switch_thres_offset;
3032
3033 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3034 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3035 tmp, 0);
3036 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3037 coex_dm->switch_thres_offset;
3038 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3039
3040 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3041
3042 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3043 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3044
3045 if (BTC_RSSI_HIGH(bt_rssi_state))
3046 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3047 else
3048 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3049
3050 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3051 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3052
3053 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3054 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3055 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3056 false, false);
3057 } else {
3058 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3059 false, false);
3060 }
3061 }
3062
3063 /* PAN(EDR) + A2DP */
3064 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
3065 {
3066 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3067 u32 wifi_bw;
3068 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3069 coex_dm->switch_thres_offset;
3070
3071 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3072 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3073 tmp, 0);
3074 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3075 coex_dm->switch_thres_offset;
3076 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3077
3078 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3079
3080 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3081
3082 if (BTC_RSSI_HIGH(bt_rssi_state))
3083 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3084 else
3085 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3086
3087 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state))
3088 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3089 0x0, 0x0);
3090 else
3091 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3092 0x4);
3093 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3094
3095 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3096 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3097 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 12);
3098 if (BTC_WIFI_BW_HT40 == wifi_bw)
3099 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3100 true, 3);
3101 else
3102 btc8723b2ant_tdma_duration_adjust(btcoexist, false,
3103 false, 3);
3104 } else {
3105 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3106 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
3107 }
3108
3109 /* sw mechanism */
3110 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3111 btc8723b2ant_sw_mechanism(btcoexist, true, false,
3112 false, false);
3113 } else {
3114 btc8723b2ant_sw_mechanism(btcoexist, false, false,
3115 false, false);
3116 }
3117 }
3118
3119 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
3120 {
3121 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3122 u32 wifi_bw;
3123 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3124 coex_dm->switch_thres_offset;
3125
3126 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3127 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3128 tmp, 0);
3129 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3130 coex_dm->switch_thres_offset;
3131 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3132 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3133
3134 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3135
3136 if (BTC_RSSI_HIGH(bt_rssi_state))
3137 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3138 else
3139 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3140
3141 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3142 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3143 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3144 0x0, 0x0);
3145 } else {
3146 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3147 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3148 0x4);
3149 }
3150
3151 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3152 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3153 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3154 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3155 3);
3156 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3157 0xfffff, 0x780);
3158 } else {
3159 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
3160 6);
3161 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
3162 0xfffff, 0x0);
3163 }
3164 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
3165 } else {
3166 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3167 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
3168 0x0);
3169 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
3170 }
3171
3172 /* sw mechanism */
3173 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3174 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3175 false, false);
3176 } else {
3177 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3178 false, false);
3179 }
3180 }
3181
3182 /* HID + A2DP + PAN(EDR) */
3183 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
3184 {
3185 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3186 u32 wifi_bw;
3187 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3188 coex_dm->switch_thres_offset;
3189
3190 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3191 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3192 tmp, 0);
3193 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3194 coex_dm->switch_thres_offset;
3195 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 2, tmp, 0);
3196
3197 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3198
3199 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 0x8);
3200 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3201
3202 if (BTC_RSSI_HIGH(bt_rssi_state))
3203 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3204 else
3205 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3206
3207 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3208 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3209 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3210 0x0, 0x0);
3211 } else {
3212 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3213 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3214 0x4);
3215 }
3216
3217 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3218
3219
3220 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3221 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3222 if (BTC_WIFI_BW_HT40 == wifi_bw)
3223 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3224 true, 2);
3225 else
3226 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3227 false, 3);
3228 } else {
3229 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
3230 }
3231
3232 /* sw mechanism */
3233 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3234 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3235 false, false);
3236 } else {
3237 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3238 false, false);
3239 }
3240 }
3241
3242 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3243 {
3244 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state;
3245 u32 wifi_bw;
3246 u8 ap_num = 0;
3247 u8 tmp = BT_8723B_2ANT_WIFI_RSSI_COEXSWITCH_THRES -
3248 coex_dm->switch_thres_offset;
3249
3250 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 0, 2, 15, 0);
3251 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 1, 2,
3252 tmp, 0);
3253 tmp = BT_8723B_2ANT_BT_RSSI_COEXSWITCH_THRES -
3254 coex_dm->switch_thres_offset;
3255 bt_rssi_state = btc8723b2ant_bt_rssi_state(btcoexist, 3, tmp, 37);
3256
3257 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
3258
3259 btc8723b2ant_limited_rx(btcoexist, NORMAL_EXEC, false, true, 0x5);
3260 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3261
3262 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3263
3264 if (wifi_bw == BTC_WIFI_BW_LEGACY) {
3265 if (BTC_RSSI_HIGH(bt_rssi_state))
3266 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3267 else if (BTC_RSSI_MEDIUM(bt_rssi_state))
3268 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3269 else
3270 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3271 } else {
3272 /* only 802.11N mode we have to dec bt power to 4 degree */
3273 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3274 /* need to check ap Number of Not */
3275 if (ap_num < 10)
3276 btc8723b2ant_dec_bt_pwr(btcoexist,
3277 NORMAL_EXEC, 4);
3278 else
3279 btc8723b2ant_dec_bt_pwr(btcoexist,
3280 NORMAL_EXEC, 2);
3281 } else if (BTC_RSSI_MEDIUM(bt_rssi_state)) {
3282 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3283 } else {
3284 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3285 }
3286 }
3287
3288 if (BTC_RSSI_HIGH(wifi_rssi_state1) && BTC_RSSI_HIGH(bt_rssi_state)) {
3289 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
3290 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3291 0x0, 0x0);
3292 } else {
3293 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 14);
3294 btc8723b2ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 0x50,
3295 0x4);
3296 }
3297
3298 if (BTC_RSSI_HIGH(bt_rssi_state)) {
3299 if (ap_num < 10)
3300 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3301 false, 1);
3302 else
3303 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3304 false, 3);
3305 } else {
3306 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 18);
3307 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
3308 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
3309 btcoexist->btc_write_4byte(btcoexist, 0x430, 0x0);
3310 btcoexist->btc_write_4byte(btcoexist, 0x434, 0x01010000);
3311
3312 if (ap_num < 10)
3313 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3314 true, 1);
3315 else
3316 btc8723b2ant_tdma_duration_adjust(btcoexist, true,
3317 true, 3);
3318 }
3319
3320 /* sw mechanism */
3321 if (BTC_WIFI_BW_HT40 == wifi_bw) {
3322 btc8723b2ant_sw_mechanism(btcoexist, true, true,
3323 false, false);
3324 } else {
3325 btc8723b2ant_sw_mechanism(btcoexist, false, true,
3326 false, false);
3327 }
3328 }
3329
3330 static void btc8723b2ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
3331 {
3332 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
3333 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3334
3335 /* sw all off */
3336 btc8723b2ant_sw_mechanism(btcoexist, false, false, false, false);
3337
3338 /* hw all off */
3339 btc8723b2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3340
3341 btc8723b2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
3342 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
3343 }
3344
3345 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3346 {
3347 struct rtl_priv *rtlpriv = btcoexist->adapter;
3348 u8 algorithm = 0;
3349 u32 num_of_wifi_link = 0;
3350 u32 wifi_link_status = 0;
3351 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3352 bool miracast_plus_bt = false;
3353 bool scan = false, link = false, roam = false;
3354
3355 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3356 "[BTCoex], RunCoexistMechanism()===>\n");
3357
3358 if (btcoexist->manual_control) {
3359 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3360 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3361 return;
3362 }
3363
3364 if (coex_sta->under_ips) {
3365 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3366 "[BTCoex], wifi is under IPS !!!\n");
3367 return;
3368 }
3369
3370 algorithm = btc8723b2ant_action_algorithm(btcoexist);
3371 if (coex_sta->c2h_bt_inquiry_page &&
3372 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
3373 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3374 "[BTCoex], BT is under inquiry/page scan !!\n");
3375 btc8723b2ant_action_bt_inquiry(btcoexist);
3376 return;
3377 }
3378
3379 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3380 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3381 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3382
3383 if (scan || link || roam) {
3384 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3385 "[BTCoex], WiFi is under Link Process !!\n");
3386 btc8723b2ant_action_wifi_link_process(btcoexist);
3387 return;
3388 }
3389
3390 /* for P2P */
3391 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3392 &wifi_link_status);
3393 num_of_wifi_link = wifi_link_status >> 16;
3394
3395 if ((num_of_wifi_link >= 2) ||
3396 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3397 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3398 "############# [BTCoex], Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3399 num_of_wifi_link, wifi_link_status);
3400
3401 if (bt_link_info->bt_link_exist)
3402 miracast_plus_bt = true;
3403 else
3404 miracast_plus_bt = false;
3405
3406 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3407 &miracast_plus_bt);
3408 btc8723b2ant_action_wifi_multi_port(btcoexist);
3409
3410 return;
3411 }
3412
3413 miracast_plus_bt = false;
3414 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3415 &miracast_plus_bt);
3416
3417 coex_dm->cur_algorithm = algorithm;
3418 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3419 "[BTCoex], Algorithm = %d\n",
3420 coex_dm->cur_algorithm);
3421
3422 if (btc8723b2ant_is_common_action(btcoexist)) {
3423 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3424 "[BTCoex], Action 2-Ant common\n");
3425 coex_dm->auto_tdma_adjust = false;
3426 } else {
3427 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3428 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3429 "[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
3430 coex_dm->pre_algorithm,
3431 coex_dm->cur_algorithm);
3432 coex_dm->auto_tdma_adjust = false;
3433 }
3434 switch (coex_dm->cur_algorithm) {
3435 case BT_8723B_2ANT_COEX_ALGO_SCO:
3436 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3437 "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3438 btc8723b2ant_action_sco(btcoexist);
3439 break;
3440 case BT_8723B_2ANT_COEX_ALGO_HID:
3441 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3442 "[BTCoex], Action 2-Ant, algorithm = HID\n");
3443 btc8723b2ant_action_hid(btcoexist);
3444 break;
3445 case BT_8723B_2ANT_COEX_ALGO_A2DP:
3446 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3447 "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3448 btc8723b2ant_action_a2dp(btcoexist);
3449 break;
3450 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
3451 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3452 "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3453 btc8723b2ant_action_a2dp_pan_hs(btcoexist);
3454 break;
3455 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
3456 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3457 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3458 btc8723b2ant_action_pan_edr(btcoexist);
3459 break;
3460 case BT_8723B_2ANT_COEX_ALGO_PANHS:
3461 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3462 "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3463 btc8723b2ant_action_pan_hs(btcoexist);
3464 break;
3465 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
3466 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3467 "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3468 btc8723b2ant_action_pan_edr_a2dp(btcoexist);
3469 break;
3470 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
3471 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3472 "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3473 btc8723b2ant_action_pan_edr_hid(btcoexist);
3474 break;
3475 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3476 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3477 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3478 btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
3479 break;
3480 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
3481 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3482 "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3483 btc8723b2ant_action_hid_a2dp(btcoexist);
3484 break;
3485 default:
3486 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3487 "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3488 btc8723b2ant_coex_alloff(btcoexist);
3489 break;
3490 }
3491 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3492 }
3493 }
3494
3495 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist)
3496 {
3497 bool is_in_mp_mode = false;
3498 u8 h2c_parameter[2] = {0};
3499 u32 fw_ver = 0;
3500
3501 /* set wlan_act to low */
3502 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3503
3504 /* WiFi standby while GNT_BT 0 -> 1 */
3505 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
3506
3507 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3508 if (fw_ver >= 0x180000) {
3509 /* Use H2C to set GNT_BT to HIGH */
3510 h2c_parameter[0] = 1;
3511 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, h2c_parameter);
3512 } else {
3513 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18);
3514 }
3515
3516 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE,
3517 &is_in_mp_mode);
3518 if (!is_in_mp_mode)
3519 /* BT select s0/s1 is controlled by BT */
3520 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0);
3521 else
3522 /* BT select s0/s1 is controlled by WiFi */
3523 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
3524 }
3525
3526 /*********************************************************************
3527 * extern function start with ex_btc8723b2ant_
3528 *********************************************************************/
3529 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
3530 {
3531 struct rtl_priv *rtlpriv = btcoexist->adapter;
3532 u8 u8tmp = 0;
3533
3534 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3535 "[BTCoex], 2Ant Init HW Config!!\n");
3536 coex_dm->bt_rf0x1e_backup =
3537 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3538
3539 /* 0x790[5:0] = 0x5 */
3540 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3541 u8tmp &= 0xc0;
3542 u8tmp |= 0x5;
3543 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3544
3545 /* Antenna config */
3546 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN,
3547 true, false);
3548 coex_sta->dis_ver_info_cnt = 0;
3549
3550 /* PTA parameter */
3551 btc8723b2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3552
3553 /* Enable counter statistics */
3554 /* 0x76e[3] = 1, WLAN_ACT controlled by PTA */
3555 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4);
3556 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3557 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3558 btcoexist->auto_report_2ant = true;
3559 }
3560
3561 void ex_btc8723b2ant_power_on_setting(struct btc_coexist *btcoexist)
3562 {
3563 struct btc_board_info *board_info = &btcoexist->board_info;
3564 u16 u16tmp = 0x0;
3565 u32 value = 0;
3566
3567 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20);
3568
3569 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly */
3570 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
3571 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1);
3572
3573 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0);
3574
3575 if (btcoexist->chip_interface == BTC_INTF_USB) {
3576 /* fixed at S0 for USB interface */
3577 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3578 } else {
3579 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3580 if (board_info->single_ant_path == 0) {
3581 /* set to S1 */
3582 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3583 } else if (board_info->single_ant_path == 1) {
3584 /* set to S0 */
3585 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
3586 }
3587 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
3588 &value);
3589 }
3590 }
3591
3592 void ex_btc8723b2ant_pre_load_firmware(struct btc_coexist *btcoexist)
3593 {
3594 struct btc_board_info *board_info = &btcoexist->board_info;
3595 u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
3596
3597 /**
3598 * S0 or S1 setting and Local register setting(By this fw can get
3599 * ant number, S0/S1, ... info)
3600 *
3601 * Local setting bit define
3602 * BIT0: "0" : no antenna inverse; "1" : antenna inverse
3603 * BIT1: "0" : internal switch; "1" : external switch
3604 * BIT2: "0" : one antenna; "1" : two antennas
3605 *
3606 * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and
3607 * BIT2 = 0
3608 */
3609 if (btcoexist->chip_interface == BTC_INTF_USB) {
3610 /* fixed at S0 for USB interface */
3611 u8tmp |= 0x1; /* antenna inverse */
3612 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
3613 } else {
3614 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
3615 if (board_info->single_ant_path == 0) {
3616 } else if (board_info->single_ant_path == 1) {
3617 /* set to S0 */
3618 u8tmp |= 0x1; /* antenna inverse */
3619 }
3620
3621 if (btcoexist->chip_interface == BTC_INTF_PCI)
3622 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384,
3623 u8tmp);
3624 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
3625 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
3626 u8tmp);
3627 }
3628 }
3629
3630 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3631 {
3632 struct rtl_priv *rtlpriv = btcoexist->adapter;
3633
3634 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3635 "[BTCoex], Coex Mechanism Init!!\n");
3636 btc8723b2ant_init_coex_dm(btcoexist);
3637 }
3638
3639 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist,
3640 struct seq_file *m)
3641 {
3642 struct btc_board_info *board_info = &btcoexist->board_info;
3643 struct btc_stack_info *stack_info = &btcoexist->stack_info;
3644 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3645 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3646 u32 u32tmp[4];
3647 bool roam = false, scan = false;
3648 bool link = false, wifi_under_5g = false;
3649 bool bt_hs_on = false, wifi_busy = false;
3650 s32 wifi_rssi = 0, bt_hs_rssi = 0;
3651 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3652 u8 wifi_dot11_chnl, wifi_hs_chnl;
3653 u32 fw_ver = 0, bt_patch_ver = 0;
3654 u8 ap_num = 0;
3655
3656 seq_puts(m, "\n ============[BT Coexist info]============");
3657
3658 if (btcoexist->manual_control) {
3659 seq_puts(m, "\n ==========[Under Manual Control]============");
3660 seq_puts(m, "\n ==========================================");
3661 }
3662
3663 seq_printf(m, "\n %-35s = %d/ %d ",
3664 "Ant PG number/ Ant mechanism:",
3665 board_info->pg_ant_num, board_info->btdm_ant_num);
3666
3667 seq_printf(m, "\n %-35s = %s / %d",
3668 "BT stack/ hci ext ver",
3669 ((stack_info->profile_notified) ? "Yes" : "No"),
3670 stack_info->hci_version);
3671
3672 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3673 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3674 seq_printf(m, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3675 "CoexVer/ FwVer/ PatchVer",
3676 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3677 fw_ver, bt_patch_ver, bt_patch_ver);
3678
3679 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3680 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3681 &wifi_dot11_chnl);
3682 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3683
3684 seq_printf(m, "\n %-35s = %d / %d(%d)",
3685 "Dot11 channel / HsChnl(HsMode)",
3686 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3687
3688 seq_printf(m, "\n %-35s = %3ph ",
3689 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info);
3690
3691 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3692 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3693 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num);
3694 seq_printf(m, "\n %-35s = %d/ %d/ %d",
3695 "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num);
3696
3697 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3698 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3699 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3700 seq_printf(m, "\n %-35s = %d/ %d/ %d ",
3701 "Wifi link/ roam/ scan", link, roam, scan);
3702
3703 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3704 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3705 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3706 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3707 &wifi_traffic_dir);
3708 seq_printf(m, "\n %-35s = %s / %s/ %s ",
3709 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3710 ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
3711 (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
3712 ((!wifi_busy) ? "idle" :
3713 ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
3714 "uplink" : "downlink")));
3715
3716 seq_printf(m, "\n %-35s = %d / %d / %d / %d",
3717 "SCO/HID/PAN/A2DP",
3718 bt_link_info->sco_exist, bt_link_info->hid_exist,
3719 bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3720 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO, m);
3721
3722 bt_info_ext = coex_sta->bt_info_ext;
3723 seq_printf(m, "\n %-35s = %s",
3724 "BT Info A2DP rate",
3725 (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate");
3726
3727 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3728 if (coex_sta->bt_info_c2h_cnt[i]) {
3729 seq_printf(m, "\n %-35s = %7ph(%d)",
3730 glbt_info_src_8723b_2ant[i],
3731 coex_sta->bt_info_c2h[i],
3732 coex_sta->bt_info_c2h_cnt[i]);
3733 }
3734 }
3735
3736 seq_printf(m, "\n %-35s = %s/%s",
3737 "PS state, IPS/LPS",
3738 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3739 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3740 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
3741
3742 /* Sw mechanism */
3743 seq_printf(m,
3744 "\n %-35s", "============[Sw mechanism]============");
3745 seq_printf(m, "\n %-35s = %d/ %d/ %d ",
3746 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3747 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3748 seq_printf(m, "\n %-35s = %d/ %d/ %d(0x%x) ",
3749 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3750 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3751 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3752
3753 /* Fw mechanism */
3754 seq_printf(m, "\n %-35s",
3755 "============[Fw mechanism]============");
3756
3757 ps_tdma_case = coex_dm->cur_ps_tdma;
3758 seq_printf(m, "\n %-35s = %5ph case-%d (auto:%d)",
3759 "PS TDMA", coex_dm->ps_tdma_para,
3760 ps_tdma_case, coex_dm->auto_tdma_adjust);
3761
3762 seq_printf(m, "\n %-35s = %d/ %d ",
3763 "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr_lvl,
3764 coex_dm->cur_ignore_wlan_act);
3765
3766 /* Hw setting */
3767 seq_printf(m, "\n %-35s",
3768 "============[Hw setting]============");
3769
3770 seq_printf(m, "\n %-35s = 0x%x",
3771 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3772
3773 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3774 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3775 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3776 "0x778/0x880[29:25]", u8tmp[0],
3777 (u32tmp[0] & 0x3e000000) >> 25);
3778
3779 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3780 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3781 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3782 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3783 "0x948/ 0x67[5] / 0x765",
3784 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]);
3785
3786 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3787 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3788 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3789 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3790 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3791 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3);
3792
3793 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3794 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3795 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3796 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3797 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3798 "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3799 ((u8tmp[0] & 0x8) >> 3), u8tmp[1],
3800 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1);
3801
3802 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3803 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3804 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3805 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3806
3807 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3808 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3809 seq_printf(m, "\n %-35s = 0x%x/ 0x%x",
3810 "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]);
3811
3812 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3813 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3814 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3815 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3816
3817 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3818 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3819
3820 fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3821 ((u32tmp[1]&0xffff0000) >> 16) +
3822 (u32tmp[1] & 0xffff) +
3823 (u32tmp[2] & 0xffff) +
3824 ((u32tmp[3]&0xffff0000) >> 16) +
3825 (u32tmp[3] & 0xffff);
3826 fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3827
3828 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
3829 "OFDM-CCA/OFDM-FA/CCK-FA",
3830 u32tmp[0] & 0xffff, fa_ofdm, fa_cck);
3831
3832 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3833 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3834 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3835 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3836 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3837 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3838 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3839
3840 seq_printf(m, "\n %-35s = %d/ %d",
3841 "0x770(high-pri rx/tx)",
3842 coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3843 seq_printf(m, "\n %-35s = %d/ %d",
3844 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
3845 coex_sta->low_priority_tx);
3846 if (btcoexist->auto_report_2ant)
3847 btc8723b2ant_monitor_bt_ctr(btcoexist);
3848 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
3849 }
3850
3851 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3852 {
3853 struct rtl_priv *rtlpriv = btcoexist->adapter;
3854
3855 if (BTC_IPS_ENTER == type) {
3856 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3857 "[BTCoex], IPS ENTER notify\n");
3858 coex_sta->under_ips = true;
3859 btc8723b2ant_wifioff_hwcfg(btcoexist);
3860 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3861 btc8723b2ant_coex_alloff(btcoexist);
3862 } else if (BTC_IPS_LEAVE == type) {
3863 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3864 "[BTCoex], IPS LEAVE notify\n");
3865 coex_sta->under_ips = false;
3866 ex_btc8723b2ant_init_hwconfig(btcoexist);
3867 btc8723b2ant_init_coex_dm(btcoexist);
3868 btc8723b2ant_query_bt_info(btcoexist);
3869 }
3870 }
3871
3872 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3873 {
3874 struct rtl_priv *rtlpriv = btcoexist->adapter;
3875
3876 if (BTC_LPS_ENABLE == type) {
3877 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3878 "[BTCoex], LPS ENABLE notify\n");
3879 coex_sta->under_lps = true;
3880 } else if (BTC_LPS_DISABLE == type) {
3881 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3882 "[BTCoex], LPS DISABLE notify\n");
3883 coex_sta->under_lps = false;
3884 }
3885 }
3886
3887 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3888 {
3889 struct rtl_priv *rtlpriv = btcoexist->adapter;
3890 u32 u32tmp;
3891 u8 u8tmpa, u8tmpb;
3892
3893 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948);
3894 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765);
3895 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x76e);
3896
3897 if (BTC_SCAN_START == type)
3898 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3899 "[BTCoex], SCAN START notify\n");
3900 else if (BTC_SCAN_FINISH == type)
3901 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3902 "[BTCoex], SCAN FINISH notify\n");
3903 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3904 &coex_sta->scan_ap_num);
3905
3906 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3907 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x76e=0x%x\n",
3908 u32tmp, u8tmpa, u8tmpb);
3909 }
3910
3911 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3912 {
3913 struct rtl_priv *rtlpriv = btcoexist->adapter;
3914
3915 if (BTC_ASSOCIATE_START == type)
3916 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3917 "[BTCoex], CONNECT START notify\n");
3918 else if (BTC_ASSOCIATE_FINISH == type)
3919 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3920 "[BTCoex], CONNECT FINISH notify\n");
3921 }
3922
3923 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist,
3924 u8 type)
3925 {
3926 struct rtl_priv *rtlpriv = btcoexist->adapter;
3927 u8 h2c_parameter[3] = {0};
3928 u32 wifi_bw;
3929 u8 wifi_central_chnl;
3930 u8 ap_num = 0;
3931
3932 if (BTC_MEDIA_CONNECT == type)
3933 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3934 "[BTCoex], MEDIA connect notify\n");
3935 else
3936 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3937 "[BTCoex], MEDIA disconnect notify\n");
3938
3939 /* only 2.4G we need to inform bt the chnl mask */
3940 btcoexist->btc_get(btcoexist,
3941 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
3942 if ((BTC_MEDIA_CONNECT == type) &&
3943 (wifi_central_chnl <= 14)) {
3944 h2c_parameter[0] = 0x1;
3945 h2c_parameter[1] = wifi_central_chnl;
3946 btcoexist->btc_get(btcoexist,
3947 BTC_GET_U4_WIFI_BW, &wifi_bw);
3948 if (wifi_bw == BTC_WIFI_BW_HT40) {
3949 h2c_parameter[2] = 0x30;
3950 } else {
3951 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3952 &ap_num);
3953 if (ap_num < 10)
3954 h2c_parameter[2] = 0x30;
3955 else
3956 h2c_parameter[2] = 0x20;
3957 }
3958 }
3959
3960 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3961 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3962 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3963
3964 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3965 "[BTCoex], FW write 0x66=0x%x\n",
3966 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3967 h2c_parameter[2]);
3968
3969 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3970 }
3971
3972 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
3973 u8 type)
3974 {
3975 struct rtl_priv *rtlpriv = btcoexist->adapter;
3976
3977 if (type == BTC_PACKET_DHCP)
3978 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3979 "[BTCoex], DHCP Packet notify\n");
3980 }
3981
3982 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
3983 u8 *tmpbuf, u8 length)
3984 {
3985 struct rtl_priv *rtlpriv = btcoexist->adapter;
3986 u8 bt_info = 0;
3987 u8 i, rsp_source = 0;
3988 bool bt_busy = false, limited_dig = false;
3989 bool wifi_connected = false;
3990
3991 coex_sta->c2h_bt_info_req_sent = false;
3992
3993 rsp_source = tmpbuf[0]&0xf;
3994 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
3995 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3996 coex_sta->bt_info_c2h_cnt[rsp_source]++;
3997
3998 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3999 "[BTCoex], Bt info[%d], length=%d, hex data=[",
4000 rsp_source, length);
4001 for (i = 0; i < length; i++) {
4002 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
4003 if (i == 1)
4004 bt_info = tmpbuf[i];
4005 if (i == length - 1)
4006 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4007 "0x%02x]\n", tmpbuf[i]);
4008 else
4009 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4010 "0x%02x, ", tmpbuf[i]);
4011 }
4012
4013 if (btcoexist->manual_control) {
4014 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4015 "[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n");
4016 return;
4017 }
4018
4019 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
4020 coex_sta->bt_retry_cnt =
4021 coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
4022
4023 if (coex_sta->bt_retry_cnt >= 1)
4024 coex_sta->pop_event_cnt++;
4025
4026 coex_sta->bt_rssi =
4027 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
4028
4029 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
4030
4031 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20)
4032 coex_sta->c2h_bt_remote_name_req = true;
4033 else
4034 coex_sta->c2h_bt_remote_name_req = false;
4035
4036 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49)
4037 coex_sta->a2dp_bit_pool =
4038 coex_sta->bt_info_c2h[rsp_source][6];
4039 else
4040 coex_sta->a2dp_bit_pool = 0;
4041
4042 /* Here we need to resend some wifi info to BT
4043 * because BT is reset and loss of the info.
4044 */
4045 if ((coex_sta->bt_info_ext & BIT1)) {
4046 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4047 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
4048 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
4049 &wifi_connected);
4050 if (wifi_connected)
4051 ex_btc8723b2ant_media_status_notify(
4052 btcoexist,
4053 BTC_MEDIA_CONNECT);
4054 else
4055 ex_btc8723b2ant_media_status_notify(
4056 btcoexist,
4057 BTC_MEDIA_DISCONNECT);
4058 }
4059
4060 if ((coex_sta->bt_info_ext & BIT3)) {
4061 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4062 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
4063 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
4064 false);
4065 } else {
4066 /* BT already NOT ignore Wlan active, do nothing here.*/
4067 }
4068 if (!btcoexist->auto_report_2ant) {
4069 if (!(coex_sta->bt_info_ext & BIT4))
4070 btc8723b2ant_bt_auto_report(btcoexist,
4071 FORCE_EXEC, true);
4072 }
4073 }
4074
4075 /* check BIT2 first ==> check if bt is under inquiry or page scan */
4076 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
4077 coex_sta->c2h_bt_inquiry_page = true;
4078 else
4079 coex_sta->c2h_bt_inquiry_page = false;
4080
4081 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4082 /* set link exist status */
4083 coex_sta->bt_link_exist = false;
4084 coex_sta->pan_exist = false;
4085 coex_sta->a2dp_exist = false;
4086 coex_sta->hid_exist = false;
4087 coex_sta->sco_exist = false;
4088 } else {
4089 /* connection exists */
4090 coex_sta->bt_link_exist = true;
4091 if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
4092 coex_sta->pan_exist = true;
4093 else
4094 coex_sta->pan_exist = false;
4095 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
4096 coex_sta->a2dp_exist = true;
4097 else
4098 coex_sta->a2dp_exist = false;
4099 if (bt_info & BT_INFO_8723B_2ANT_B_HID)
4100 coex_sta->hid_exist = true;
4101 else
4102 coex_sta->hid_exist = false;
4103 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
4104 coex_sta->sco_exist = true;
4105 else
4106 coex_sta->sco_exist = false;
4107
4108 if ((!coex_sta->hid_exist) &&
4109 (!coex_sta->c2h_bt_inquiry_page) &&
4110 (!coex_sta->sco_exist)) {
4111 if (coex_sta->high_priority_tx +
4112 coex_sta->high_priority_rx >= 160) {
4113 coex_sta->hid_exist = true;
4114 bt_info = bt_info | 0x28;
4115 }
4116 }
4117 }
4118
4119 btc8723b2ant_update_bt_link_info(btcoexist);
4120
4121 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
4122 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
4123 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4124 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
4125 /* connection exists but no busy */
4126 } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
4127 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
4128 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4129 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
4130 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
4131 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
4132 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
4133 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4134 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
4135 } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
4136 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
4137 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4138 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
4139 } else {
4140 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
4141 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4142 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
4143 }
4144
4145 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
4146 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
4147 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
4148 bt_busy = true;
4149 limited_dig = true;
4150 } else {
4151 bt_busy = false;
4152 limited_dig = false;
4153 }
4154
4155 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
4156
4157 coex_dm->limited_dig = limited_dig;
4158 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
4159
4160 btc8723b2ant_run_coexist_mechanism(btcoexist);
4161 }
4162
4163 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
4164 {
4165 struct rtl_priv *rtlpriv = btcoexist->adapter;
4166
4167 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n");
4168
4169 btc8723b2ant_wifioff_hwcfg(btcoexist);
4170 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
4171 ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
4172 }
4173
4174 void ex_btc8723b2ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
4175 {
4176 struct rtl_priv *rtlpriv = btcoexist->adapter;
4177
4178 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n");
4179
4180 if (pnp_state == BTC_WIFI_PNP_SLEEP) {
4181 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4182 "[BTCoex], Pnp notify to SLEEP\n");
4183
4184 /* Driver do not leave IPS/LPS when driver is going to sleep, so
4185 * BTCoexistence think wifi is still under IPS/LPS
4186 *
4187 * BT should clear UnderIPS/UnderLPS state to avoid mismatch
4188 * state after wakeup.
4189 */
4190 coex_sta->under_ips = false;
4191 coex_sta->under_lps = false;
4192 } else if (pnp_state == BTC_WIFI_PNP_WAKE_UP) {
4193 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4194 "[BTCoex], Pnp notify to WAKE UP\n");
4195 ex_btc8723b2ant_init_hwconfig(btcoexist);
4196 btc8723b2ant_init_coex_dm(btcoexist);
4197 btc8723b2ant_query_bt_info(btcoexist);
4198 }
4199 }
4200
4201 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist)
4202 {
4203 struct rtl_priv *rtlpriv = btcoexist->adapter;
4204 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
4205
4206 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4207 "[BTCoex], ==========================Periodical===========================\n");
4208
4209 if (coex_sta->dis_ver_info_cnt <= 5) {
4210 coex_sta->dis_ver_info_cnt += 1;
4211 if (coex_sta->dis_ver_info_cnt == 3) {
4212 /* Antenna config to set 0x765 = 0x0 (GNT_BT control by
4213 * PTA) after initial
4214 */
4215 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
4216 "[BTCoex], Set GNT_BT control by PTA\n");
4217 btc8723b2ant_set_ant_path(
4218 btcoexist, BTC_ANT_WIFI_AT_MAIN, false, false);
4219 }
4220 }
4221
4222 if (!btcoexist->auto_report_2ant) {
4223 btc8723b2ant_query_bt_info(btcoexist);
4224 } else {
4225 btc8723b2ant_monitor_bt_ctr(btcoexist);
4226 btc8723b2ant_monitor_wifi_ctr(btcoexist);
4227
4228 /* for some BT speakers that High-Priority pkts appear before
4229 * playing, this will cause HID exist
4230 */
4231 if ((coex_sta->high_priority_tx +
4232 coex_sta->high_priority_rx < 50) &&
4233 (bt_link_info->hid_exist))
4234 bt_link_info->hid_exist = false;
4235
4236 if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
4237 coex_dm->auto_tdma_adjust)
4238 btc8723b2ant_run_coexist_mechanism(btcoexist);
4239 }
4240 }
Linux with added FPC-III support