1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2012  Realtek Corporation.*/
3 
4 /**************************************************************
5  * Description:
6  *
7  * This file is for RTL8821A Co-exist mechanism
8  *
9  * History
10  * 2012/11/15 Cosa first check in.
11  *
12  **************************************************************/
13 
14 /**************************************************************
15  * include files
16  **************************************************************/
17 #include "halbt_precomp.h"
18 /**************************************************************
19  * Global variables, these are static variables
20  **************************************************************/
21 static struct coex_dm_8821a_1ant glcoex_dm_8821a_1ant;
22 static struct coex_dm_8821a_1ant *coex_dm = &glcoex_dm_8821a_1ant;
23 static struct coex_sta_8821a_1ant glcoex_sta_8821a_1ant;
24 static struct coex_sta_8821a_1ant *coex_sta = &glcoex_sta_8821a_1ant;
25 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
26 						  u8 wifi_status);
27 
28 static const char *const glbt_info_src_8821a_1ant[] = {
29 	  "BT Info[wifi fw]",
30 	  "BT Info[bt rsp]",
31 	  "BT Info[bt auto report]",
32 };
33 
34 static u32 glcoex_ver_date_8821a_1ant = 20130816;
35 static u32 glcoex_ver_8821a_1ant = 0x41;
36 
37 /**************************************************************
38  * local function proto type if needed
39  *
40  * local function start with btc8821a1ant_
41  **************************************************************/
btc8821a1ant_bt_rssi_state(struct btc_coexist * btcoexist,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)42 static u8 btc8821a1ant_bt_rssi_state(struct btc_coexist *btcoexist,
43 				     u8 level_num, u8 rssi_thresh,
44 				     u8 rssi_thresh1)
45 {
46 	struct rtl_priv *rtlpriv = btcoexist->adapter;
47 	long bt_rssi = 0;
48 	u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
49 
50 	bt_rssi = coex_sta->bt_rssi;
51 
52 	if (level_num == 2) {
53 		if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
54 		    (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
55 			if (bt_rssi >= (rssi_thresh +
56 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
57 				bt_rssi_state = BTC_RSSI_STATE_HIGH;
58 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
59 					"[BTCoex], BT Rssi state switch to High\n");
60 			} else {
61 				bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
62 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
63 					"[BTCoex], BT Rssi state stay at Low\n");
64 			}
65 		} else {
66 			if (bt_rssi < rssi_thresh) {
67 				bt_rssi_state = BTC_RSSI_STATE_LOW;
68 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
69 					"[BTCoex], BT Rssi state switch to Low\n");
70 			} else {
71 				bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
72 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
73 					"[BTCoex], BT Rssi state stay at High\n");
74 			}
75 		}
76 	} else if (level_num == 3) {
77 		if (rssi_thresh > rssi_thresh1) {
78 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
79 				"[BTCoex], BT Rssi thresh error!!\n");
80 			return coex_sta->pre_bt_rssi_state;
81 		}
82 
83 		if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
84 		    (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
85 			if (bt_rssi >= (rssi_thresh +
86 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
87 				bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
88 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
89 					"[BTCoex], BT Rssi state switch to Medium\n");
90 			} else {
91 				bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
92 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
93 					"[BTCoex], BT Rssi state stay at Low\n");
94 			}
95 		} else if ((coex_sta->pre_bt_rssi_state ==
96 			   BTC_RSSI_STATE_MEDIUM) ||
97 			   (coex_sta->pre_bt_rssi_state ==
98 			    BTC_RSSI_STATE_STAY_MEDIUM)) {
99 			if (bt_rssi >= (rssi_thresh1 +
100 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
101 				bt_rssi_state = BTC_RSSI_STATE_HIGH;
102 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
103 					"[BTCoex], BT Rssi state switch to High\n");
104 			} else if (bt_rssi < rssi_thresh) {
105 				bt_rssi_state = BTC_RSSI_STATE_LOW;
106 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
107 					"[BTCoex], BT Rssi state switch to Low\n");
108 			} else {
109 				bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
110 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
111 					"[BTCoex], BT Rssi state stay at Medium\n");
112 			}
113 		} else {
114 			if (bt_rssi < rssi_thresh1) {
115 				bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
116 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
117 					"[BTCoex], BT Rssi state switch to Medium\n");
118 			} else {
119 				bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
120 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
121 					"[BTCoex], BT Rssi state stay at High\n");
122 			}
123 		}
124 	}
125 	coex_sta->pre_bt_rssi_state = bt_rssi_state;
126 
127 	return bt_rssi_state;
128 }
129 
btc8821a1ant_wifi_rssi_state(struct btc_coexist * btcoexist,u8 index,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)130 static u8 btc8821a1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
131 				       u8 index, u8 level_num, u8 rssi_thresh,
132 				       u8 rssi_thresh1)
133 {
134 	struct rtl_priv *rtlpriv = btcoexist->adapter;
135 	long	wifi_rssi = 0;
136 	u8	wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
137 
138 	btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
139 
140 	if (level_num == 2) {
141 		if ((coex_sta->pre_wifi_rssi_state[index] ==
142 		     BTC_RSSI_STATE_LOW) ||
143 		    (coex_sta->pre_wifi_rssi_state[index] ==
144 		     BTC_RSSI_STATE_STAY_LOW)) {
145 			if (wifi_rssi >= (rssi_thresh +
146 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
147 				wifi_rssi_state = BTC_RSSI_STATE_HIGH;
148 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
149 					"[BTCoex], wifi RSSI state switch to High\n");
150 			} else {
151 				wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
152 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
153 					"[BTCoex], wifi RSSI state stay at Low\n");
154 			}
155 		} else {
156 			if (wifi_rssi < rssi_thresh) {
157 				wifi_rssi_state = BTC_RSSI_STATE_LOW;
158 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
159 					"[BTCoex], wifi RSSI state switch to Low\n");
160 			} else {
161 				wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
162 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
163 					"[BTCoex], wifi RSSI state stay at High\n");
164 			}
165 		}
166 	} else if (level_num == 3) {
167 		if (rssi_thresh > rssi_thresh1) {
168 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
169 				"[BTCoex], wifi RSSI thresh error!!\n");
170 			return coex_sta->pre_wifi_rssi_state[index];
171 		}
172 
173 		if ((coex_sta->pre_wifi_rssi_state[index] ==
174 		     BTC_RSSI_STATE_LOW) ||
175 		    (coex_sta->pre_wifi_rssi_state[index] ==
176 		     BTC_RSSI_STATE_STAY_LOW)) {
177 			if (wifi_rssi >= (rssi_thresh +
178 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
179 				wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
180 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
181 					"[BTCoex], wifi RSSI state switch to Medium\n");
182 			} else {
183 				wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
184 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
185 					"[BTCoex], wifi RSSI state stay at Low\n");
186 			}
187 		} else if ((coex_sta->pre_wifi_rssi_state[index] ==
188 			BTC_RSSI_STATE_MEDIUM) ||
189 			(coex_sta->pre_wifi_rssi_state[index] ==
190 			BTC_RSSI_STATE_STAY_MEDIUM)) {
191 			if (wifi_rssi >= (rssi_thresh1 +
192 					BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
193 				wifi_rssi_state = BTC_RSSI_STATE_HIGH;
194 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
195 					"[BTCoex], wifi RSSI state switch to High\n");
196 			} else if (wifi_rssi < rssi_thresh) {
197 				wifi_rssi_state = BTC_RSSI_STATE_LOW;
198 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
199 					"[BTCoex], wifi RSSI state switch to Low\n");
200 			} else {
201 				wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
202 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
203 					"[BTCoex], wifi RSSI state stay at Medium\n");
204 			}
205 		} else {
206 			if (wifi_rssi < rssi_thresh1) {
207 				wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
208 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
209 					"[BTCoex], wifi RSSI state switch to Medium\n");
210 			} else {
211 				wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
212 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
213 					"[BTCoex], wifi RSSI state stay at High\n");
214 			}
215 		}
216 	}
217 	coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
218 
219 	return wifi_rssi_state;
220 }
221 
btc8821a1ant_update_ra_mask(struct btc_coexist * btcoexist,bool force_exec,u32 dis_rate_mask)222 static void btc8821a1ant_update_ra_mask(struct btc_coexist *btcoexist,
223 					bool force_exec, u32 dis_rate_mask)
224 {
225 	coex_dm->cur_ra_mask = dis_rate_mask;
226 
227 	if (force_exec ||
228 	    (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask)) {
229 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
230 				   &coex_dm->cur_ra_mask);
231 	}
232 	coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
233 }
234 
btc8821a1ant_auto_rate_fb_retry(struct btc_coexist * btcoexist,bool force_exec,u8 type)235 static void btc8821a1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist,
236 					    bool force_exec, u8 type)
237 {
238 	bool wifi_under_b_mode = false;
239 
240 	coex_dm->cur_arfr_type = type;
241 
242 	if (force_exec ||
243 	    (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
244 		switch (coex_dm->cur_arfr_type) {
245 		case 0:	/* normal mode */
246 			btcoexist->btc_write_4byte(btcoexist, 0x430,
247 						   coex_dm->backup_arfr_cnt1);
248 			btcoexist->btc_write_4byte(btcoexist, 0x434,
249 						   coex_dm->backup_arfr_cnt2);
250 			break;
251 		case 1:
252 			btcoexist->btc_get(btcoexist,
253 					   BTC_GET_BL_WIFI_UNDER_B_MODE,
254 					   &wifi_under_b_mode);
255 			if (wifi_under_b_mode) {
256 				btcoexist->btc_write_4byte(btcoexist, 0x430,
257 							   0x0);
258 				btcoexist->btc_write_4byte(btcoexist, 0x434,
259 							   0x01010101);
260 			} else {
261 				btcoexist->btc_write_4byte(btcoexist, 0x430,
262 							   0x0);
263 				btcoexist->btc_write_4byte(btcoexist, 0x434,
264 							   0x04030201);
265 			}
266 			break;
267 		default:
268 			break;
269 		}
270 	}
271 
272 	coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
273 }
274 
btc8821a1ant_retry_limit(struct btc_coexist * btcoexist,bool force_exec,u8 type)275 static void btc8821a1ant_retry_limit(struct btc_coexist *btcoexist,
276 				     bool force_exec, u8 type)
277 {
278 	coex_dm->cur_retry_limit_type = type;
279 
280 	if (force_exec ||
281 	    (coex_dm->pre_retry_limit_type != coex_dm->cur_retry_limit_type)) {
282 		switch (coex_dm->cur_retry_limit_type) {
283 		case 0:	/* normal mode */
284 			btcoexist->btc_write_2byte(btcoexist, 0x42a,
285 						   coex_dm->backup_retry_limit);
286 			break;
287 		case 1:	/* retry limit = 8 */
288 			btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
289 			break;
290 		default:
291 			break;
292 		}
293 	}
294 	coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
295 }
296 
btc8821a1ant_ampdu_max_time(struct btc_coexist * btcoexist,bool force_exec,u8 type)297 static void btc8821a1ant_ampdu_max_time(struct btc_coexist *btcoexist,
298 					bool force_exec, u8 type)
299 {
300 	coex_dm->cur_ampdu_time_type = type;
301 
302 	if (force_exec ||
303 	    (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
304 		switch (coex_dm->cur_ampdu_time_type) {
305 		case 0:	/* normal mode */
306 			btcoexist->btc_write_1byte(btcoexist, 0x456,
307 						   coex_dm->backup_ampdu_max_time);
308 			break;
309 		case 1:	/* AMPDU time = 0x38 * 32us */
310 			btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
311 			break;
312 		default:
313 			break;
314 		}
315 	}
316 
317 	coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
318 }
319 
btc8821a1ant_limited_tx(struct btc_coexist * btcoexist,bool force_exec,u8 ra_mask_type,u8 arfr_type,u8 retry_limit_type,u8 ampdu_time_type)320 static void btc8821a1ant_limited_tx(struct btc_coexist *btcoexist,
321 				    bool force_exec, u8 ra_mask_type,
322 				    u8 arfr_type, u8 retry_limit_type,
323 				    u8 ampdu_time_type)
324 {
325 	switch (ra_mask_type) {
326 	case 0:	/* normal mode */
327 		btc8821a1ant_update_ra_mask(btcoexist, force_exec, 0x0);
328 		break;
329 	case 1:	/* disable cck 1/2 */
330 		btc8821a1ant_update_ra_mask(btcoexist, force_exec,
331 					    0x00000003);
332 		break;
333 	case 2:	/* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
334 		btc8821a1ant_update_ra_mask(btcoexist, force_exec,
335 					    0x0001f1f7);
336 		break;
337 	default:
338 		break;
339 	}
340 
341 	btc8821a1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type);
342 	btc8821a1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
343 	btc8821a1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
344 }
345 
btc8821a1ant_limited_rx(struct btc_coexist * btcoexist,bool force_exec,bool rej_ap_agg_pkt,bool bt_ctrl_agg_buf_size,u8 agg_buf_size)346 static void btc8821a1ant_limited_rx(struct btc_coexist *btcoexist,
347 				    bool force_exec, bool rej_ap_agg_pkt,
348 				    bool bt_ctrl_agg_buf_size, u8 agg_buf_size)
349 {
350 	bool reject_rx_agg = rej_ap_agg_pkt;
351 	bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
352 	u8 rx_agg_size = agg_buf_size;
353 
354 	/* Rx Aggregation related setting */
355 	btcoexist->btc_set(btcoexist,
356 		 BTC_SET_BL_TO_REJ_AP_AGG_PKT, &reject_rx_agg);
357 	/* decide BT control aggregation buf size or not */
358 	btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
359 			   &bt_ctrl_rx_agg_size);
360 	/* aggregation buf size, only work when BT control Rx agg size */
361 	btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
362 	/* real update aggregation setting */
363 	btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
364 }
365 
btc8821a1ant_monitor_bt_ctr(struct btc_coexist * btcoexist)366 static void btc8821a1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
367 {
368 	u32 reg_hp_tx_rx, reg_lp_tx_rx, u4_tmp;
369 	u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
370 
371 	reg_hp_tx_rx = 0x770;
372 	reg_lp_tx_rx = 0x774;
373 
374 	u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_tx_rx);
375 	reg_hp_tx = u4_tmp & MASKLWORD;
376 	reg_hp_rx = (u4_tmp & MASKHWORD) >> 16;
377 
378 	u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_tx_rx);
379 	reg_lp_tx = u4_tmp & MASKLWORD;
380 	reg_lp_rx = (u4_tmp & MASKHWORD) >> 16;
381 
382 	coex_sta->high_priority_tx = reg_hp_tx;
383 	coex_sta->high_priority_rx = reg_hp_rx;
384 	coex_sta->low_priority_tx = reg_lp_tx;
385 	coex_sta->low_priority_rx = reg_lp_rx;
386 
387 	/* reset counter */
388 	btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
389 }
390 
btc8821a1ant_query_bt_info(struct btc_coexist * btcoexist)391 static void btc8821a1ant_query_bt_info(struct btc_coexist *btcoexist)
392 {
393 	struct rtl_priv *rtlpriv = btcoexist->adapter;
394 	u8 h2c_parameter[1] = {0};
395 
396 	coex_sta->c2h_bt_info_req_sent = true;
397 
398 	h2c_parameter[0] |= BIT0; /* trigger */
399 
400 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
401 		"[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
402 		h2c_parameter[0]);
403 
404 	btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
405 }
406 
btc8821a1ant_update_bt_link_info(struct btc_coexist * btcoexist)407 static void btc8821a1ant_update_bt_link_info(struct btc_coexist *btcoexist)
408 {
409 	struct btc_bt_link_info	*bt_link_info = &btcoexist->bt_link_info;
410 	bool bt_hs_on = false;
411 
412 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
413 
414 	bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
415 	bt_link_info->sco_exist = coex_sta->sco_exist;
416 	bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
417 	bt_link_info->pan_exist = coex_sta->pan_exist;
418 	bt_link_info->hid_exist = coex_sta->hid_exist;
419 
420 	/* work around for HS mode */
421 	if (bt_hs_on) {
422 		bt_link_info->pan_exist = true;
423 		bt_link_info->bt_link_exist = true;
424 	}
425 
426 	/* check if Sco only */
427 	if (bt_link_info->sco_exist &&
428 	    !bt_link_info->a2dp_exist &&
429 	    !bt_link_info->pan_exist &&
430 	    !bt_link_info->hid_exist)
431 		bt_link_info->sco_only = true;
432 	else
433 		bt_link_info->sco_only = false;
434 
435 	/* check if A2dp only */
436 	if (!bt_link_info->sco_exist &&
437 	    bt_link_info->a2dp_exist &&
438 	    !bt_link_info->pan_exist &&
439 	    !bt_link_info->hid_exist)
440 		bt_link_info->a2dp_only = true;
441 	else
442 		bt_link_info->a2dp_only = false;
443 
444 	/* check if Pan only */
445 	if (!bt_link_info->sco_exist &&
446 	    !bt_link_info->a2dp_exist &&
447 	    bt_link_info->pan_exist &&
448 	    !bt_link_info->hid_exist)
449 		bt_link_info->pan_only = true;
450 	else
451 		bt_link_info->pan_only = false;
452 
453 	/* check if Hid only */
454 	if (!bt_link_info->sco_exist &&
455 	    !bt_link_info->a2dp_exist &&
456 	    !bt_link_info->pan_exist &&
457 	    bt_link_info->hid_exist)
458 		bt_link_info->hid_only = true;
459 	else
460 		bt_link_info->hid_only = false;
461 }
462 
btc8821a1ant_action_algorithm(struct btc_coexist * btcoexist)463 static u8 btc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
464 {
465 	struct rtl_priv *rtlpriv = btcoexist->adapter;
466 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
467 	bool bt_hs_on = false;
468 	u8 algorithm = BT_8821A_1ANT_COEX_ALGO_UNDEFINED;
469 	u8 num_of_diff_profile = 0;
470 
471 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
472 
473 	if (!bt_link_info->bt_link_exist) {
474 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
475 			"[BTCoex], No BT link exists!!!\n");
476 		return algorithm;
477 	}
478 
479 	if (bt_link_info->sco_exist)
480 		num_of_diff_profile++;
481 	if (bt_link_info->hid_exist)
482 		num_of_diff_profile++;
483 	if (bt_link_info->pan_exist)
484 		num_of_diff_profile++;
485 	if (bt_link_info->a2dp_exist)
486 		num_of_diff_profile++;
487 
488 	if (num_of_diff_profile == 1) {
489 		if (bt_link_info->sco_exist) {
490 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
491 				"[BTCoex], BT Profile = SCO only\n");
492 			algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
493 		} else {
494 			if (bt_link_info->hid_exist) {
495 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
496 					"[BTCoex], BT Profile = HID only\n");
497 				algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
498 			} else if (bt_link_info->a2dp_exist) {
499 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
500 					"[BTCoex], BT Profile = A2DP only\n");
501 				algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP;
502 			} else if (bt_link_info->pan_exist) {
503 				if (bt_hs_on) {
504 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
505 						DBG_LOUD,
506 						"[BTCoex], BT Profile = PAN(HS) only\n");
507 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANHS;
508 				} else {
509 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
510 						DBG_LOUD,
511 						"[BTCoex], BT Profile = PAN(EDR) only\n");
512 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR;
513 				}
514 			}
515 		}
516 	} else if (num_of_diff_profile == 2) {
517 		if (bt_link_info->sco_exist) {
518 			if (bt_link_info->hid_exist) {
519 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
520 					"[BTCoex], BT Profile = SCO + HID\n");
521 				algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
522 			} else if (bt_link_info->a2dp_exist) {
523 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
524 					"[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
525 				algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
526 			} else if (bt_link_info->pan_exist) {
527 				if (bt_hs_on) {
528 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
529 						DBG_LOUD,
530 						"[BTCoex], BT Profile = SCO + PAN(HS)\n");
531 					algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
532 				} else {
533 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
534 						DBG_LOUD,
535 						"[BTCoex], BT Profile = SCO + PAN(EDR)\n");
536 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
537 				}
538 			}
539 		} else {
540 			if (bt_link_info->hid_exist &&
541 			    bt_link_info->a2dp_exist) {
542 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
543 					"[BTCoex], BT Profile = HID + A2DP\n");
544 				algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
545 			} else if (bt_link_info->hid_exist &&
546 				   bt_link_info->pan_exist) {
547 				if (bt_hs_on) {
548 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
549 						DBG_LOUD,
550 						"[BTCoex], BT Profile = HID + PAN(HS)\n");
551 					algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
552 				} else {
553 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
554 						DBG_LOUD,
555 						"[BTCoex], BT Profile = HID + PAN(EDR)\n");
556 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
557 				}
558 			} else if (bt_link_info->pan_exist &&
559 				   bt_link_info->a2dp_exist) {
560 				if (bt_hs_on) {
561 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
562 						DBG_LOUD,
563 						"[BTCoex], BT Profile = A2DP + PAN(HS)\n");
564 					algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS;
565 				} else {
566 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
567 						DBG_LOUD,
568 						"[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
569 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP;
570 				}
571 			}
572 		}
573 	} else if (num_of_diff_profile == 3) {
574 		if (bt_link_info->sco_exist) {
575 			if (bt_link_info->hid_exist &&
576 			    bt_link_info->a2dp_exist) {
577 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
578 					"[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
579 				algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
580 			} else if (bt_link_info->hid_exist &&
581 				   bt_link_info->pan_exist) {
582 				if (bt_hs_on) {
583 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
584 						DBG_LOUD,
585 						"[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
586 					algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
587 				} else {
588 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
589 						DBG_LOUD,
590 						"[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
591 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
592 				}
593 			} else if (bt_link_info->pan_exist &&
594 				   bt_link_info->a2dp_exist) {
595 				if (bt_hs_on) {
596 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
597 						DBG_LOUD,
598 						"[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
599 					algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
600 				} else {
601 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
602 						DBG_LOUD,
603 						"[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
604 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
605 				}
606 			}
607 		} else {
608 			if (bt_link_info->hid_exist &&
609 			    bt_link_info->pan_exist &&
610 			    bt_link_info->a2dp_exist) {
611 				if (bt_hs_on) {
612 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
613 						DBG_LOUD,
614 						"[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
615 					algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
616 				} else {
617 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
618 						DBG_LOUD,
619 						"[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
620 					algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
621 				}
622 			}
623 		}
624 	} else if (num_of_diff_profile >= 3) {
625 		if (bt_link_info->sco_exist) {
626 			if (bt_link_info->hid_exist &&
627 			    bt_link_info->pan_exist &&
628 			    bt_link_info->a2dp_exist) {
629 				if (bt_hs_on) {
630 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
631 						DBG_LOUD,
632 						"[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
633 
634 				} else {
635 					rtl_dbg(rtlpriv, COMP_BT_COEXIST,
636 						DBG_LOUD,
637 						"[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
638 					algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
639 				}
640 			}
641 		}
642 	}
643 	return algorithm;
644 }
645 
btc8821a1ant_set_sw_penalty_tx_rate(struct btc_coexist * btcoexist,bool low_penalty_ra)646 static void btc8821a1ant_set_sw_penalty_tx_rate(struct btc_coexist *btcoexist,
647 						bool low_penalty_ra)
648 {
649 	struct rtl_priv *rtlpriv = btcoexist->adapter;
650 	u8 h2c_parameter[6] = {0};
651 
652 	h2c_parameter[0] = 0x6;	/* opCode, 0x6= Retry_Penalty*/
653 
654 	if (low_penalty_ra) {
655 		h2c_parameter[1] |= BIT0;
656 		/* normal rate except MCS7/6/5, OFDM54/48/36 */
657 		h2c_parameter[2] = 0x00;
658 		h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
659 		h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
660 		h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
661 	}
662 
663 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
664 		"[BTCoex], set WiFi Low-Penalty Retry: %s",
665 		(low_penalty_ra ? "ON!!" : "OFF!!"));
666 
667 	btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
668 }
669 
btc8821a1ant_low_penalty_ra(struct btc_coexist * btcoexist,bool force_exec,bool low_penalty_ra)670 static void btc8821a1ant_low_penalty_ra(struct btc_coexist *btcoexist,
671 					bool force_exec, bool low_penalty_ra)
672 {
673 	coex_dm->cur_low_penalty_ra = low_penalty_ra;
674 
675 	if (!force_exec) {
676 		if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
677 			return;
678 	}
679 	btc8821a1ant_set_sw_penalty_tx_rate(btcoexist,
680 					    coex_dm->cur_low_penalty_ra);
681 
682 	coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
683 }
684 
btc8821a1ant_set_coex_table(struct btc_coexist * btcoexist,u32 val0x6c0,u32 val0x6c4,u32 val0x6c8,u8 val0x6cc)685 static void btc8821a1ant_set_coex_table(struct btc_coexist *btcoexist,
686 					u32 val0x6c0, u32 val0x6c4,
687 					u32 val0x6c8, u8 val0x6cc)
688 {
689 	struct rtl_priv *rtlpriv = btcoexist->adapter;
690 
691 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
692 		"[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
693 	btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
694 
695 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
696 		"[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
697 	btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
698 
699 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
700 		"[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
701 	btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
702 
703 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
704 		"[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
705 	btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
706 }
707 
btc8821a1ant_coex_table(struct btc_coexist * btcoexist,bool force_exec,u32 val0x6c0,u32 val0x6c4,u32 val0x6c8,u8 val0x6cc)708 static void btc8821a1ant_coex_table(struct btc_coexist *btcoexist,
709 				    bool force_exec, u32 val0x6c0, u32 val0x6c4,
710 				    u32 val0x6c8, u8 val0x6cc)
711 {
712 	struct rtl_priv *rtlpriv = btcoexist->adapter;
713 
714 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
715 		"[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
716 		(force_exec ? "force to" : ""), val0x6c0, val0x6c4,
717 		val0x6c8, val0x6cc);
718 	coex_dm->cur_val_0x6c0 = val0x6c0;
719 	coex_dm->cur_val_0x6c4 = val0x6c4;
720 	coex_dm->cur_val_0x6c8 = val0x6c8;
721 	coex_dm->cur_val_0x6cc = val0x6cc;
722 
723 	if (!force_exec) {
724 		if ((coex_dm->pre_val_0x6c0 == coex_dm->cur_val_0x6c0) &&
725 		    (coex_dm->pre_val_0x6c4 == coex_dm->cur_val_0x6c4) &&
726 		    (coex_dm->pre_val_0x6c8 == coex_dm->cur_val_0x6c8) &&
727 		    (coex_dm->pre_val_0x6cc == coex_dm->cur_val_0x6cc))
728 			return;
729 	}
730 	btc8821a1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
731 				    val0x6c8, val0x6cc);
732 
733 	coex_dm->pre_val_0x6c0 = coex_dm->cur_val_0x6c0;
734 	coex_dm->pre_val_0x6c4 = coex_dm->cur_val_0x6c4;
735 	coex_dm->pre_val_0x6c8 = coex_dm->cur_val_0x6c8;
736 	coex_dm->pre_val_0x6cc = coex_dm->cur_val_0x6cc;
737 }
738 
btc8821a1ant_coex_table_with_type(struct btc_coexist * btcoexist,bool force_exec,u8 type)739 static void btc8821a1ant_coex_table_with_type(struct btc_coexist *btcoexist,
740 					      bool force_exec, u8 type)
741 {
742 	switch (type) {
743 	case 0:
744 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
745 					0x55555555, 0xffffff, 0x3);
746 		break;
747 	case 1:
748 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
749 					0x5a5a5a5a, 0xffffff, 0x3);
750 		break;
751 	case 2:
752 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
753 					0x5a5a5a5a, 0xffffff, 0x3);
754 		break;
755 	case 3:
756 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
757 					0xaaaaaaaa, 0xffffff, 0x3);
758 		break;
759 	case 4:
760 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
761 					0x5a5a5a5a, 0xffffff, 0x3);
762 		break;
763 	case 5:
764 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
765 					0xaaaa5a5a, 0xffffff, 0x3);
766 		break;
767 	case 6:
768 		btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
769 					0xaaaa5a5a, 0xffffff, 0x3);
770 		break;
771 	case 7:
772 		btc8821a1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
773 					0xaaaaaaaa, 0xffffff, 0x3);
774 		break;
775 	default:
776 		break;
777 	}
778 }
779 
btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist * btcoexist,bool enable)780 static void btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
781 						bool enable)
782 {
783 	struct rtl_priv *rtlpriv = btcoexist->adapter;
784 	u8 h2c_parameter[1] = {0};
785 
786 	if (enable)
787 		h2c_parameter[0] |= BIT0; /* function enable */
788 
789 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
790 		"[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
791 		h2c_parameter[0]);
792 
793 	btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
794 }
795 
btc8821a1ant_ignore_wlan_act(struct btc_coexist * btcoexist,bool force_exec,bool enable)796 static void btc8821a1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
797 					 bool force_exec, bool enable)
798 {
799 	struct rtl_priv *rtlpriv = btcoexist->adapter;
800 
801 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
802 		"[BTCoex], %s turn Ignore WlanAct %s\n",
803 		(force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
804 	coex_dm->cur_ignore_wlan_act = enable;
805 
806 	if (!force_exec) {
807 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
808 			"[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
809 			coex_dm->pre_ignore_wlan_act,
810 			 coex_dm->cur_ignore_wlan_act);
811 
812 		if (coex_dm->pre_ignore_wlan_act ==
813 		    coex_dm->cur_ignore_wlan_act)
814 			return;
815 	}
816 	btc8821a1ant_set_fw_ignore_wlan_act(btcoexist, enable);
817 
818 	coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
819 }
820 
btc8821a1ant_set_fw_ps_tdma(struct btc_coexist * btcoexist,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)821 static void btc8821a1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
822 					u8 byte2, u8 byte3, u8 byte4, u8 byte5)
823 {
824 	struct rtl_priv *rtlpriv = btcoexist->adapter;
825 	u8 h2c_parameter[5] = {0};
826 	u8 real_byte1 = byte1, real_byte5 = byte5;
827 	bool ap_enable = false;
828 
829 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
830 			   &ap_enable);
831 
832 	if (ap_enable) {
833 		if (byte1 & BIT4 && !(byte1 & BIT5)) {
834 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
835 				"[BTCoex], FW for 1Ant AP mode\n");
836 			real_byte1 &= ~BIT4;
837 			real_byte1 |= BIT5;
838 
839 			real_byte5 |= BIT5;
840 			real_byte5 &= ~BIT6;
841 		}
842 	}
843 
844 	h2c_parameter[0] = real_byte1;
845 	h2c_parameter[1] = byte2;
846 	h2c_parameter[2] = byte3;
847 	h2c_parameter[3] = byte4;
848 	h2c_parameter[4] = real_byte5;
849 
850 	coex_dm->ps_tdma_para[0] = real_byte1;
851 	coex_dm->ps_tdma_para[1] = byte2;
852 	coex_dm->ps_tdma_para[2] = byte3;
853 	coex_dm->ps_tdma_para[3] = byte4;
854 	coex_dm->ps_tdma_para[4] = real_byte5;
855 
856 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
857 		"[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
858 		h2c_parameter[0],
859 		h2c_parameter[1] << 24 |
860 		h2c_parameter[2] << 16 |
861 		h2c_parameter[3] << 8 |
862 		h2c_parameter[4]);
863 	btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
864 }
865 
btc8821a1ant_set_lps_rpwm(struct btc_coexist * btcoexist,u8 lps_val,u8 rpwm_val)866 static void btc8821a1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
867 				      u8 lps_val, u8 rpwm_val)
868 {
869 	u8 lps = lps_val;
870 	u8 rpwm = rpwm_val;
871 
872 	btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
873 	btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
874 }
875 
btc8821a1ant_lps_rpwm(struct btc_coexist * btcoexist,bool force_exec,u8 lps_val,u8 rpwm_val)876 static void btc8821a1ant_lps_rpwm(struct btc_coexist *btcoexist,
877 				  bool force_exec, u8 lps_val, u8 rpwm_val)
878 {
879 	struct rtl_priv *rtlpriv = btcoexist->adapter;
880 
881 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
882 		"[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
883 		(force_exec ? "force to" : ""), lps_val, rpwm_val);
884 	coex_dm->cur_lps = lps_val;
885 	coex_dm->cur_rpwm = rpwm_val;
886 
887 	if (!force_exec) {
888 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
889 			"[BTCoex], LPS-RxBeaconMode = 0x%x, LPS-RPWM = 0x%x!!\n",
890 			coex_dm->cur_lps, coex_dm->cur_rpwm);
891 
892 		if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
893 		    (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
894 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
895 				"[BTCoex], LPS-RPWM_Last = 0x%x, LPS-RPWM_Now = 0x%x!!\n",
896 				coex_dm->pre_rpwm, coex_dm->cur_rpwm);
897 
898 			return;
899 		}
900 	}
901 	btc8821a1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
902 
903 	coex_dm->pre_lps = coex_dm->cur_lps;
904 	coex_dm->pre_rpwm = coex_dm->cur_rpwm;
905 }
906 
btc8821a1ant_sw_mechanism(struct btc_coexist * btcoexist,bool low_penalty_ra)907 static void btc8821a1ant_sw_mechanism(struct btc_coexist *btcoexist,
908 				      bool low_penalty_ra)
909 {
910 	struct rtl_priv *rtlpriv = btcoexist->adapter;
911 
912 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
913 		"[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
914 
915 	btc8821a1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
916 }
917 
btc8821a1ant_set_ant_path(struct btc_coexist * btcoexist,u8 ant_pos_type,bool init_hw_cfg,bool wifi_off)918 static void btc8821a1ant_set_ant_path(struct btc_coexist *btcoexist,
919 				      u8 ant_pos_type, bool init_hw_cfg,
920 				      bool wifi_off)
921 {
922 	struct btc_board_info *board_info = &btcoexist->board_info;
923 	u32 u4_tmp = 0;
924 	u8 h2c_parameter[2] = {0};
925 
926 	if (init_hw_cfg) {
927 		/* 0x4c[23] = 0, 0x4c[24] = 1  Antenna control by WL/BT */
928 		u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
929 		u4_tmp &= ~BIT23;
930 		u4_tmp |= BIT24;
931 		btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
932 
933 		btcoexist->btc_write_1byte_bitmask(btcoexist, 0x975, 0x3, 0x3);
934 		btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
935 
936 		if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
937 			/* tell firmware "antenna inverse"
938 			 * WRONG firmware antenna control code, need fw to fix
939 			 */
940 			h2c_parameter[0] = 1;
941 			h2c_parameter[1] = 1;
942 			btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
943 						h2c_parameter);
944 		} else {
945 			/* tell firmware "no antenna inverse"
946 			 * WRONG firmware antenna control code, need fw to fix
947 			 */
948 			h2c_parameter[0] = 0;
949 			h2c_parameter[1] = 1;
950 			btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
951 						h2c_parameter);
952 		}
953 	} else if (wifi_off) {
954 		/* 0x4c[24:23] = 00, Set Antenna control
955 		 * by BT_RFE_CTRL BT Vendor 0xac = 0xf002
956 		 */
957 		u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
958 		u4_tmp &= ~BIT23;
959 		u4_tmp &= ~BIT24;
960 		btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
961 
962 		/* 0x765 = 0x18 */
963 		btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
964 	} else {
965 		/* 0x765 = 0x0 */
966 		btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
967 	}
968 
969 	/* ext switch setting */
970 	switch (ant_pos_type) {
971 	case BTC_ANT_PATH_WIFI:
972 		btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
973 		if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
974 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
975 							   0x30, 0x1);
976 		else
977 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
978 							   0x30, 0x2);
979 		break;
980 	case BTC_ANT_PATH_BT:
981 		btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
982 		if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
983 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
984 							   0x30, 0x2);
985 		else
986 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
987 							   0x30, 0x1);
988 		break;
989 	default:
990 	case BTC_ANT_PATH_PTA:
991 		btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x66);
992 		if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
993 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
994 							   0x30, 0x1);
995 		else
996 			btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
997 							   0x30, 0x2);
998 		break;
999 	}
1000 }
1001 
btc8821a1ant_ps_tdma(struct btc_coexist * btcoexist,bool force_exec,bool turn_on,u8 type)1002 static void btc8821a1ant_ps_tdma(struct btc_coexist *btcoexist,
1003 				 bool force_exec, bool turn_on, u8 type)
1004 {
1005 	struct rtl_priv *rtlpriv = btcoexist->adapter;
1006 	u8 rssi_adjust_val = 0;
1007 
1008 	coex_dm->cur_ps_tdma_on = turn_on;
1009 	coex_dm->cur_ps_tdma = type;
1010 
1011 	if (!force_exec) {
1012 		if (coex_dm->cur_ps_tdma_on) {
1013 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1014 				"[BTCoex], ********** TDMA(on, %d) **********\n",
1015 				coex_dm->cur_ps_tdma);
1016 		} else {
1017 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1018 				"[BTCoex], ********** TDMA(off, %d) **********\n",
1019 				coex_dm->cur_ps_tdma);
1020 		}
1021 		if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1022 		    (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1023 			return;
1024 	}
1025 	if (turn_on) {
1026 		switch (type) {
1027 		default:
1028 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1a,
1029 						    0x1a, 0x0, 0x50);
1030 			break;
1031 		case 1:
1032 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x3a,
1033 						    0x03, 0x10, 0x50);
1034 			rssi_adjust_val = 11;
1035 			break;
1036 		case 2:
1037 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x2b,
1038 						    0x03, 0x10, 0x50);
1039 			rssi_adjust_val = 14;
1040 			break;
1041 		case 3:
1042 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1d,
1043 						    0x1d, 0x0, 0x10);
1044 			break;
1045 		case 4:
1046 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1047 						    0x3, 0x14, 0x0);
1048 			rssi_adjust_val = 17;
1049 			break;
1050 		case 5:
1051 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x15,
1052 						    0x3, 0x11, 0x10);
1053 			break;
1054 		case 6:
1055 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x20,
1056 						    0x3, 0x11, 0x13);
1057 			break;
1058 		case 7:
1059 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xc,
1060 						    0x5, 0x0, 0x0);
1061 			break;
1062 		case 8:
1063 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1064 						    0x3, 0x10, 0x0);
1065 			break;
1066 		case 9:
1067 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x21,
1068 						    0x3, 0x10, 0x50);
1069 			rssi_adjust_val = 18;
1070 			break;
1071 		case 10:
1072 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1073 						    0xa, 0x0, 0x40);
1074 			break;
1075 		case 11:
1076 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1077 						    0x03, 0x10, 0x50);
1078 			rssi_adjust_val = 20;
1079 			break;
1080 		case 12:
1081 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x0a,
1082 						    0x0a, 0x0, 0x50);
1083 			break;
1084 		case 13:
1085 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x12,
1086 						    0x12, 0x0, 0x50);
1087 			break;
1088 		case 14:
1089 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1e,
1090 						    0x3, 0x10, 0x14);
1091 			break;
1092 		case 15:
1093 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1094 						    0x3, 0x8, 0x0);
1095 			break;
1096 		case 16:
1097 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1098 						    0x3, 0x10, 0x0);
1099 			rssi_adjust_val = 18;
1100 			break;
1101 		case 18:
1102 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1103 						    0x3, 0x10, 0x0);
1104 			rssi_adjust_val = 14;
1105 			break;
1106 		case 20:
1107 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1108 						    0x03, 0x11, 0x10);
1109 			break;
1110 		case 21:
1111 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1112 						    0x03, 0x11, 0x11);
1113 			break;
1114 		case 22:
1115 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1116 						    0x03, 0x11, 0x10);
1117 			break;
1118 		case 23:
1119 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1120 						    0x3, 0x31, 0x18);
1121 			rssi_adjust_val = 22;
1122 			break;
1123 		case 24:
1124 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1125 						    0x3, 0x31, 0x18);
1126 			rssi_adjust_val = 22;
1127 			break;
1128 		case 25:
1129 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1130 						    0x3, 0x31, 0x18);
1131 			rssi_adjust_val = 22;
1132 			break;
1133 		case 26:
1134 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1135 						    0x3, 0x31, 0x18);
1136 			rssi_adjust_val = 22;
1137 			break;
1138 		case 27:
1139 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1140 						    0x3, 0x31, 0x98);
1141 			rssi_adjust_val = 22;
1142 			break;
1143 		case 28:
1144 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x69, 0x25,
1145 						    0x3, 0x31, 0x0);
1146 			break;
1147 		case 29:
1148 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xab, 0x1a,
1149 						    0x1a, 0x1, 0x10);
1150 			break;
1151 		case 30:
1152 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1153 						    0x3, 0x10, 0x10);
1154 			break;
1155 		case 31:
1156 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1a,
1157 						    0x1a, 0, 0x58);
1158 			break;
1159 		case 32:
1160 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1161 						    0x3, 0x11, 0x11);
1162 			break;
1163 		case 33:
1164 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x25,
1165 						    0x3, 0x30, 0x90);
1166 			break;
1167 		case 34:
1168 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x53, 0x1a,
1169 						    0x1a, 0x0, 0x10);
1170 			break;
1171 		case 35:
1172 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x63, 0x1a,
1173 						    0x1a, 0x0, 0x10);
1174 			break;
1175 		case 36:
1176 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x12,
1177 						    0x3, 0x14, 0x50);
1178 			break;
1179 		case 40:
1180 			/* SoftAP only with no sta associated, BT disable, TDMA
1181 			 * mode for power saving
1182 			 *
1183 			 * here softap mode screen off will cost 70-80mA for
1184 			 * phone
1185 			 */
1186 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x23, 0x18,
1187 						    0x00, 0x10, 0x24);
1188 			break;
1189 		case 41:
1190 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1191 						    0x3, 0x11, 0x11);
1192 			break;
1193 		case 42:
1194 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x20,
1195 						    0x3, 0x11, 0x11);
1196 			break;
1197 		case 43:
1198 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1199 						    0x3, 0x10, 0x11);
1200 			break;
1201 		}
1202 	} else {
1203 		/* disable PS tdma */
1204 		switch (type) {
1205 		case 8:
1206 			/* PTA Control */
1207 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x8, 0x0, 0x0,
1208 						    0x0, 0x0);
1209 			btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1210 						  false, false);
1211 			break;
1212 		case 0:
1213 		default:
1214 			/* Software control, Antenna at BT side */
1215 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1216 						    0x0, 0x0);
1217 			btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1218 						  false, false);
1219 			break;
1220 		case 9:
1221 			/* Software control, Antenna at WiFi side */
1222 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1223 						    0x0, 0x0);
1224 			btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
1225 						  false, false);
1226 			break;
1227 		case 10:
1228 			/* under 5G */
1229 			btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1230 						    0x8, 0x0);
1231 			btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1232 						  false, false);
1233 			break;
1234 		}
1235 	}
1236 	rssi_adjust_val = 0;
1237 	btcoexist->btc_set(btcoexist,
1238 		 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
1239 
1240 	/* update pre state */
1241 	coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1242 	coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1243 }
1244 
btc8821a1ant_is_common_action(struct btc_coexist * btcoexist)1245 static bool btc8821a1ant_is_common_action(struct btc_coexist *btcoexist)
1246 {
1247 	struct rtl_priv *rtlpriv = btcoexist->adapter;
1248 	bool common = false, wifi_connected = false, wifi_busy = false;
1249 
1250 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1251 			   &wifi_connected);
1252 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1253 
1254 	if (!wifi_connected &&
1255 	    BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1256 	    coex_dm->bt_status) {
1257 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1258 			"[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
1259 		btc8821a1ant_sw_mechanism(btcoexist, false);
1260 
1261 		common = true;
1262 	} else if (wifi_connected &&
1263 		   (BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1264 		    coex_dm->bt_status)) {
1265 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1266 			"[BTCoex], Wifi connected + BT non connected-idle!!\n");
1267 		btc8821a1ant_sw_mechanism(btcoexist, false);
1268 
1269 		common = true;
1270 	} else if (!wifi_connected &&
1271 		   (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1272 		    coex_dm->bt_status)) {
1273 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1274 			"[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
1275 		btc8821a1ant_sw_mechanism(btcoexist, false);
1276 
1277 		common = true;
1278 	} else if (wifi_connected &&
1279 		   (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1280 		    coex_dm->bt_status)) {
1281 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1282 			"[BTCoex], Wifi connected + BT connected-idle!!\n");
1283 		btc8821a1ant_sw_mechanism(btcoexist, false);
1284 
1285 		common = true;
1286 	} else if (!wifi_connected &&
1287 		   (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE !=
1288 		    coex_dm->bt_status)) {
1289 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1290 			"[BTCoex], Wifi non connected-idle + BT Busy!!\n");
1291 		btc8821a1ant_sw_mechanism(btcoexist, false);
1292 
1293 		common = true;
1294 	} else {
1295 		if (wifi_busy) {
1296 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1297 				"[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1298 		} else {
1299 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1300 				"[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1301 		}
1302 
1303 		common = false;
1304 	}
1305 
1306 	return common;
1307 }
1308 
btc8821a1ant_ps_tdma_check_for_pwr_save(struct btc_coexist * btcoex,bool new_ps_state)1309 static void btc8821a1ant_ps_tdma_check_for_pwr_save(struct btc_coexist *btcoex,
1310 						    bool new_ps_state)
1311 {
1312 	u8 lps_mode = 0x0;
1313 
1314 	btcoex->btc_get(btcoex, BTC_GET_U1_LPS_MODE, &lps_mode);
1315 
1316 	if (lps_mode) {
1317 		/* already under LPS state */
1318 		if (new_ps_state) {
1319 			/* keep state under LPS, do nothing */
1320 		} else {
1321 			/* will leave LPS state, turn off psTdma first */
1322 			btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1323 		}
1324 	} else {
1325 		/* NO PS state*/
1326 		if (new_ps_state) {
1327 			/* will enter LPS state, turn off psTdma first */
1328 			btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1329 		} else {
1330 			/* keep state under NO PS state, do nothing */
1331 		}
1332 	}
1333 }
1334 
btc8821a1ant_power_save_state(struct btc_coexist * btcoexist,u8 ps_type,u8 lps_val,u8 rpwm_val)1335 static void btc8821a1ant_power_save_state(struct btc_coexist *btcoexist,
1336 					  u8 ps_type, u8 lps_val, u8 rpwm_val)
1337 {
1338 	bool low_pwr_disable = false;
1339 
1340 	switch (ps_type) {
1341 	case BTC_PS_WIFI_NATIVE:
1342 		/* recover to original 32k low power setting */
1343 		low_pwr_disable = false;
1344 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1345 				   &low_pwr_disable);
1346 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1347 		break;
1348 	case BTC_PS_LPS_ON:
1349 		btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist,
1350 							true);
1351 		btc8821a1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1352 				      rpwm_val);
1353 		/* when coex force to enter LPS, do not enter 32k low power */
1354 		low_pwr_disable = true;
1355 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1356 				   &low_pwr_disable);
1357 		/* power save must executed before psTdma */
1358 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1359 		break;
1360 	case BTC_PS_LPS_OFF:
1361 		btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist, false);
1362 		btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1363 		break;
1364 	default:
1365 		break;
1366 	}
1367 }
1368 
btc8821a1ant_coex_under_5g(struct btc_coexist * btcoexist)1369 static void btc8821a1ant_coex_under_5g(struct btc_coexist *btcoexist)
1370 {
1371 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1372 				      0x0, 0x0);
1373 	btc8821a1ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1374 
1375 	btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 10);
1376 
1377 	btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1378 
1379 	btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1380 
1381 	btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 5);
1382 }
1383 
1384 /***********************************************
1385  *
1386  *	Software Coex Mechanism start
1387  *
1388  ***********************************************/
1389 
1390 /* SCO only or SCO+PAN(HS) */
btc8821a1ant_action_sco(struct btc_coexist * btcoexist)1391 static void btc8821a1ant_action_sco(struct btc_coexist *btcoexist)
1392 {
1393 	btc8821a1ant_sw_mechanism(btcoexist, true);
1394 }
1395 
btc8821a1ant_action_hid(struct btc_coexist * btcoexist)1396 static void btc8821a1ant_action_hid(struct btc_coexist *btcoexist)
1397 {
1398 	btc8821a1ant_sw_mechanism(btcoexist, true);
1399 }
1400 
1401 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
btc8821a1ant_action_a2dp(struct btc_coexist * btcoexist)1402 static void btc8821a1ant_action_a2dp(struct btc_coexist *btcoexist)
1403 {
1404 	btc8821a1ant_sw_mechanism(btcoexist, false);
1405 }
1406 
btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist * btcoexist)1407 static void btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
1408 {
1409 	btc8821a1ant_sw_mechanism(btcoexist, false);
1410 }
1411 
btc8821a1ant_action_pan_edr(struct btc_coexist * btcoexist)1412 static void btc8821a1ant_action_pan_edr(struct btc_coexist *btcoexist)
1413 {
1414 	btc8821a1ant_sw_mechanism(btcoexist, false);
1415 }
1416 
1417 /* PAN(HS) only */
btc8821a1ant_action_pan_hs(struct btc_coexist * btcoexist)1418 static void btc8821a1ant_action_pan_hs(struct btc_coexist *btcoexist)
1419 {
1420 	btc8821a1ant_sw_mechanism(btcoexist, false);
1421 }
1422 
1423 /* PAN(EDR)+A2DP */
btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist * btcoexist)1424 static void btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
1425 {
1426 	btc8821a1ant_sw_mechanism(btcoexist, false);
1427 }
1428 
btc8821a1ant_action_pan_edr_hid(struct btc_coexist * btcoexist)1429 static void btc8821a1ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
1430 {
1431 	btc8821a1ant_sw_mechanism(btcoexist, true);
1432 }
1433 
1434 /* HID+A2DP+PAN(EDR) */
btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist * btcoexist)1435 static void btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
1436 {
1437 	btc8821a1ant_sw_mechanism(btcoexist, true);
1438 }
1439 
btc8821a1ant_action_hid_a2dp(struct btc_coexist * btcoexist)1440 static void btc8821a1ant_action_hid_a2dp(struct btc_coexist *btcoexist)
1441 {
1442 	btc8821a1ant_sw_mechanism(btcoexist, true);
1443 }
1444 
1445 /***********************************************
1446  *
1447  *	Non-Software Coex Mechanism start
1448  *
1449  ***********************************************/
1450 static
btc8821a1ant_action_wifi_multi_port(struct btc_coexist * btcoexist)1451 void btc8821a1ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
1452 {
1453 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1454 
1455 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1456 	/* tdma and coex table */
1457 	if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1458 		if (bt_link_info->a2dp_exist) {
1459 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1460 			btc8821a1ant_coex_table_with_type(btcoexist,
1461 							  NORMAL_EXEC, 1);
1462 		} else if (bt_link_info->a2dp_exist &&
1463 			   bt_link_info->pan_exist) {
1464 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1465 			btc8821a1ant_coex_table_with_type(btcoexist,
1466 							  NORMAL_EXEC, 4);
1467 		} else {
1468 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1469 			btc8821a1ant_coex_table_with_type(btcoexist,
1470 							  NORMAL_EXEC, 4);
1471 		}
1472 	} else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1473 		   (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1474 		    coex_dm->bt_status)) {
1475 		btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1476 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1477 	} else {
1478 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1479 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1480 	}
1481 }
1482 
1483 static
btc8821a1ant_action_wifi_not_connected_asso_auth(struct btc_coexist * btcoexist)1484 void btc8821a1ant_action_wifi_not_connected_asso_auth(
1485 					struct btc_coexist *btcoexist)
1486 {
1487 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1488 
1489 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
1490 				      0x0);
1491 
1492 	/* tdma and coex table */
1493 	if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
1494 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1495 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1496 	} else if ((bt_link_info->a2dp_exist) || (bt_link_info->pan_exist)) {
1497 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1498 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1499 	} else {
1500 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1501 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1502 	}
1503 }
1504 
1505 
btc8821a1ant_action_hs(struct btc_coexist * btcoexist)1506 static void btc8821a1ant_action_hs(struct btc_coexist *btcoexist)
1507 {
1508 	btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1509 	btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1510 }
1511 
btc8821a1ant_action_bt_inquiry(struct btc_coexist * btcoexist)1512 static void btc8821a1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1513 {
1514 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1515 	bool wifi_connected = false;
1516 	bool ap_enable = false;
1517 	bool wifi_busy = false, bt_busy = false;
1518 
1519 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1520 			   &wifi_connected);
1521 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1522 			   &ap_enable);
1523 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1524 	btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1525 
1526 	if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) {
1527 		btc8821a1ant_power_save_state(btcoexist,
1528 					      BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1529 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1530 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1531 	} else if ((bt_link_info->sco_exist) || (bt_link_info->a2dp_exist) ||
1532 		   (bt_link_info->hid_only)) {
1533 		/* SCO/HID-only busy */
1534 		btc8821a1ant_power_save_state(btcoexist,
1535 					      BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1536 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1537 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1538 	} else if ((bt_link_info->a2dp_exist) && (bt_link_info->hid_exist)) {
1539 		/* A2DP+HID busy */
1540 		btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1541 					      0x0, 0x0);
1542 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1543 
1544 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1545 	} else if ((bt_link_info->pan_exist) || (wifi_busy)) {
1546 		btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1547 					      0x0, 0x0);
1548 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1549 
1550 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1551 	} else {
1552 		btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1553 					      0x0, 0x0);
1554 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1555 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1556 	}
1557 }
1558 
btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist * btcoexist,u8 wifi_status)1559 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
1560 						  u8 wifi_status)
1561 {
1562 	/* tdma and coex table */
1563 	btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1564 
1565 	btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1566 }
1567 
btc8821a1ant_act_wifi_con_bt_acl_busy(struct btc_coexist * btcoexist,u8 wifi_status)1568 static void btc8821a1ant_act_wifi_con_bt_acl_busy(struct btc_coexist *btcoexist,
1569 						  u8 wifi_status)
1570 {
1571 	u8 bt_rssi_state;
1572 
1573 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1574 
1575 	bt_rssi_state = btc8821a1ant_bt_rssi_state(btcoexist, 2, 28, 0);
1576 
1577 	if (bt_link_info->hid_only) {
1578 		/* HID */
1579 		btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1580 						      wifi_status);
1581 		coex_dm->auto_tdma_adjust = false;
1582 		return;
1583 	} else if (bt_link_info->a2dp_only) {
1584 		/* A2DP */
1585 		if (wifi_status == BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1586 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1587 			btc8821a1ant_coex_table_with_type(btcoexist,
1588 							  NORMAL_EXEC, 1);
1589 			coex_dm->auto_tdma_adjust = false;
1590 		} else if ((bt_rssi_state != BTC_RSSI_STATE_HIGH) &&
1591 			   (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
1592 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1593 			btc8821a1ant_coex_table_with_type(btcoexist,
1594 							  NORMAL_EXEC, 1);
1595 		} else {
1596 			/* for low BT RSSI */
1597 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1598 			btc8821a1ant_coex_table_with_type(btcoexist,
1599 							  NORMAL_EXEC, 1);
1600 			coex_dm->auto_tdma_adjust = false;
1601 		}
1602 	} else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1603 		/* HID+A2DP (no need to consider BT RSSI) */
1604 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1605 				     true, 14);
1606 		coex_dm->auto_tdma_adjust = false;
1607 
1608 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1609 	} else if ((bt_link_info->pan_only) ||
1610 		(bt_link_info->hid_exist && bt_link_info->pan_exist)) {
1611 		/* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
1612 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1613 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
1614 		coex_dm->auto_tdma_adjust = false;
1615 	} else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
1616 		   (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
1617 		    bt_link_info->pan_exist)) {
1618 		/* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
1619 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 43);
1620 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1621 		coex_dm->auto_tdma_adjust = false;
1622 	} else {
1623 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1624 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1625 		coex_dm->auto_tdma_adjust = false;
1626 	}
1627 }
1628 
1629 static
btc8821a1ant_action_wifi_not_connected(struct btc_coexist * btcoexist)1630 void btc8821a1ant_action_wifi_not_connected(struct btc_coexist *btcoexist)
1631 {
1632 	/* power save state */
1633 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1634 
1635 	/* tdma and coex table */
1636 	btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1637 	btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1638 }
1639 
btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist * btcoexist)1640 static void btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist *btcoexist)
1641 {
1642 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1643 
1644 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1645 
1646 	/* tdma and coex table */
1647 	if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1648 		if (bt_link_info->a2dp_exist) {
1649 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1650 			btc8821a1ant_coex_table_with_type(btcoexist,
1651 							  NORMAL_EXEC, 1);
1652 		} else if (bt_link_info->a2dp_exist &&
1653 			   bt_link_info->pan_exist) {
1654 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1655 			btc8821a1ant_coex_table_with_type(btcoexist,
1656 							  NORMAL_EXEC, 4);
1657 		} else {
1658 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1659 			btc8821a1ant_coex_table_with_type(btcoexist,
1660 							  NORMAL_EXEC, 4);
1661 		}
1662 	} else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1663 		   (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1664 		    coex_dm->bt_status)) {
1665 		btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1666 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1667 	} else {
1668 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1669 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1670 	}
1671 }
1672 
1673 static
btc8821a1ant_action_wifi_connected_scan(struct btc_coexist * btcoexist)1674 void btc8821a1ant_action_wifi_connected_scan(struct btc_coexist *btcoexist)
1675 {
1676 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1677 
1678 	/* power save state */
1679 	btc8821a1ant_power_save_state(btcoexist,
1680 				      BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1681 
1682 	/* tdma and coex table */
1683 	if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1684 		if (bt_link_info->a2dp_exist) {
1685 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1686 			btc8821a1ant_coex_table_with_type(btcoexist,
1687 							  NORMAL_EXEC, 1);
1688 		} else {
1689 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1690 			btc8821a1ant_coex_table_with_type(btcoexist,
1691 							  NORMAL_EXEC, 4);
1692 		}
1693 	} else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1694 		   (coex_dm->bt_status ==
1695 		    BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY)) {
1696 		btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1697 			BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1698 	} else {
1699 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1700 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1701 	}
1702 }
1703 
btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist * btcoexist)1704 static void btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist *btcoexist)
1705 {
1706 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1707 
1708 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1709 				      0x0, 0x0);
1710 
1711 	/* tdma and coex table */
1712 	if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
1713 	    (bt_link_info->a2dp_exist)) {
1714 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1715 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1716 	}
1717 
1718 	if ((bt_link_info->hid_exist) && (bt_link_info->a2dp_exist)) {
1719 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1720 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1721 	} else if (bt_link_info->pan_exist) {
1722 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1723 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1724 	} else {
1725 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1726 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1727 	}
1728 }
1729 
btc8821a1ant_action_wifi_connected(struct btc_coexist * btcoexist)1730 static void btc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
1731 {
1732 	struct rtl_priv *rtlpriv = btcoexist->adapter;
1733 	bool wifi_busy = false;
1734 	bool scan = false, link = false, roam = false;
1735 	bool under_4way = false;
1736 	bool ap_enable = false;
1737 
1738 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1739 		"[BTCoex], CoexForWifiConnect()===>\n");
1740 
1741 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
1742 			   &under_4way);
1743 	if (under_4way) {
1744 		btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1745 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1746 			"[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
1747 		return;
1748 	}
1749 
1750 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1751 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1752 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1753 	if (scan || link || roam) {
1754 		if (scan)
1755 			btc8821a1ant_action_wifi_connected_scan(btcoexist);
1756 		else
1757 			btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1758 
1759 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1760 			"[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
1761 		return;
1762 	}
1763 
1764 	/* power save state*/
1765 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1766 			   &ap_enable);
1767 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1768 	if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY ==
1769 	    coex_dm->bt_status && !ap_enable &&
1770 	    !btcoexist->bt_link_info.hid_only) {
1771 		if (!wifi_busy && btcoexist->bt_link_info.a2dp_only)
1772 			/* A2DP */
1773 			btc8821a1ant_power_save_state(btcoexist,
1774 						BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1775 		else
1776 			btc8821a1ant_power_save_state(btcoexist, BTC_PS_LPS_ON,
1777 						      0x50, 0x4);
1778 	} else {
1779 		btc8821a1ant_power_save_state(btcoexist,
1780 					      BTC_PS_WIFI_NATIVE,
1781 					      0x0, 0x0);
1782 	}
1783 
1784 	/* tdma and coex table */
1785 	if (!wifi_busy) {
1786 		if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1787 			btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1788 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1789 		} else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1790 			    coex_dm->bt_status) ||
1791 			   (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1792 			    coex_dm->bt_status)) {
1793 			btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1794 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1795 		} else {
1796 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1797 			btc8821a1ant_coex_table_with_type(btcoexist,
1798 							  NORMAL_EXEC, 2);
1799 		}
1800 	} else {
1801 		if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1802 			btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1803 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1804 		} else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1805 			    coex_dm->bt_status) ||
1806 			   (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1807 			    coex_dm->bt_status)) {
1808 			btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1809 				BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1810 		} else {
1811 			btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1812 			btc8821a1ant_coex_table_with_type(btcoexist,
1813 							  NORMAL_EXEC, 2);
1814 		}
1815 	}
1816 }
1817 
btc8821a1ant_run_sw_coex_mech(struct btc_coexist * btcoexist)1818 static void btc8821a1ant_run_sw_coex_mech(struct btc_coexist *btcoexist)
1819 {
1820 	struct rtl_priv *rtlpriv = btcoexist->adapter;
1821 	u8 algorithm = 0;
1822 
1823 	algorithm = btc8821a1ant_action_algorithm(btcoexist);
1824 	coex_dm->cur_algorithm = algorithm;
1825 
1826 	if (!btc8821a1ant_is_common_action(btcoexist)) {
1827 		switch (coex_dm->cur_algorithm) {
1828 		case BT_8821A_1ANT_COEX_ALGO_SCO:
1829 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1830 				"[BTCoex], Action algorithm = SCO\n");
1831 			btc8821a1ant_action_sco(btcoexist);
1832 			break;
1833 		case BT_8821A_1ANT_COEX_ALGO_HID:
1834 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1835 				"[BTCoex], Action algorithm = HID\n");
1836 			btc8821a1ant_action_hid(btcoexist);
1837 			break;
1838 		case BT_8821A_1ANT_COEX_ALGO_A2DP:
1839 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1840 				"[BTCoex], Action algorithm = A2DP\n");
1841 			btc8821a1ant_action_a2dp(btcoexist);
1842 			break;
1843 		case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS:
1844 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1845 				"[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
1846 			btc8821a1ant_action_a2dp_pan_hs(btcoexist);
1847 			break;
1848 		case BT_8821A_1ANT_COEX_ALGO_PANEDR:
1849 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1850 				"[BTCoex], Action algorithm = PAN(EDR)\n");
1851 			btc8821a1ant_action_pan_edr(btcoexist);
1852 			break;
1853 		case BT_8821A_1ANT_COEX_ALGO_PANHS:
1854 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1855 				"[BTCoex], Action algorithm = HS mode\n");
1856 			btc8821a1ant_action_pan_hs(btcoexist);
1857 			break;
1858 		case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP:
1859 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1860 				"[BTCoex], Action algorithm = PAN+A2DP\n");
1861 			btc8821a1ant_action_pan_edr_a2dp(btcoexist);
1862 			break;
1863 		case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID:
1864 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1865 				"[BTCoex], Action algorithm = PAN(EDR)+HID\n");
1866 			btc8821a1ant_action_pan_edr_hid(btcoexist);
1867 			break;
1868 		case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
1869 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1870 				"[BTCoex], Action algorithm = HID+A2DP+PAN\n");
1871 			btc8821a1ant_action_hid_a2dp_pan_edr(btcoexist);
1872 			break;
1873 		case BT_8821A_1ANT_COEX_ALGO_HID_A2DP:
1874 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1875 				"[BTCoex], Action algorithm = HID+A2DP\n");
1876 			btc8821a1ant_action_hid_a2dp(btcoexist);
1877 			break;
1878 		default:
1879 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1880 				"[BTCoex], Action algorithm = coexist All Off!!\n");
1881 			/*btc8821a1ant_coex_all_off(btcoexist);*/
1882 			break;
1883 		}
1884 		coex_dm->pre_algorithm = coex_dm->cur_algorithm;
1885 	}
1886 }
1887 
btc8821a1ant_run_coexist_mechanism(struct btc_coexist * btcoexist)1888 static void btc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
1889 {
1890 	struct rtl_priv *rtlpriv = btcoexist->adapter;
1891 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1892 	bool wifi_connected = false, bt_hs_on = false;
1893 	bool increase_scan_dev_num = false;
1894 	bool bt_ctrl_agg_buf_size = false;
1895 	u8 agg_buf_size = 5;
1896 	u32 wifi_link_status = 0;
1897 	u32 num_of_wifi_link = 0;
1898 	bool wifi_under_5g = false;
1899 
1900 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1901 		"[BTCoex], RunCoexistMechanism()===>\n");
1902 
1903 	if (btcoexist->manual_control) {
1904 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1905 			"[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
1906 		return;
1907 	}
1908 
1909 	if (btcoexist->stop_coex_dm) {
1910 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1911 			"[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
1912 		return;
1913 	}
1914 
1915 	if (coex_sta->under_ips) {
1916 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1917 			"[BTCoex], wifi is under IPS !!!\n");
1918 		return;
1919 	}
1920 
1921 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
1922 	if (wifi_under_5g) {
1923 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1924 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
1925 		btc8821a1ant_coex_under_5g(btcoexist);
1926 		return;
1927 	}
1928 
1929 	if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
1930 	    (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
1931 	    (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
1932 		increase_scan_dev_num = true;
1933 
1934 	btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
1935 			   &increase_scan_dev_num);
1936 
1937 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1938 			   &wifi_connected);
1939 
1940 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
1941 			   &wifi_link_status);
1942 	num_of_wifi_link = wifi_link_status >> 16;
1943 	if ((num_of_wifi_link >= 2) ||
1944 	    (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
1945 		btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1946 		btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
1947 					bt_ctrl_agg_buf_size, agg_buf_size);
1948 		btc8821a1ant_action_wifi_multi_port(btcoexist);
1949 		return;
1950 	}
1951 
1952 	if (!bt_link_info->sco_exist && !bt_link_info->hid_exist) {
1953 		btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1954 	} else {
1955 		if (wifi_connected) {
1956 			btc8821a1ant_wifi_rssi_state(btcoexist, 1, 2,
1957 							     30, 0);
1958 			btc8821a1ant_limited_tx(btcoexist,
1959 						NORMAL_EXEC, 1, 1,
1960 						0, 1);
1961 		} else {
1962 			btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC,
1963 						0, 0, 0, 0);
1964 		}
1965 	}
1966 
1967 	if (bt_link_info->sco_exist) {
1968 		bt_ctrl_agg_buf_size = true;
1969 		agg_buf_size = 0x3;
1970 	} else if (bt_link_info->hid_exist) {
1971 		bt_ctrl_agg_buf_size = true;
1972 		agg_buf_size = 0x5;
1973 	} else if (bt_link_info->a2dp_exist || bt_link_info->pan_exist) {
1974 		bt_ctrl_agg_buf_size = true;
1975 		agg_buf_size = 0x8;
1976 	}
1977 	btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
1978 				bt_ctrl_agg_buf_size, agg_buf_size);
1979 
1980 	btc8821a1ant_run_sw_coex_mech(btcoexist);
1981 
1982 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
1983 	if (coex_sta->c2h_bt_inquiry_page) {
1984 		btc8821a1ant_action_bt_inquiry(btcoexist);
1985 		return;
1986 	} else if (bt_hs_on) {
1987 		btc8821a1ant_action_hs(btcoexist);
1988 		return;
1989 	}
1990 
1991 	if (!wifi_connected) {
1992 		bool scan = false, link = false, roam = false;
1993 
1994 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1995 			"[BTCoex], wifi is non connected-idle !!!\n");
1996 
1997 		btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1998 		btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1999 		btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2000 
2001 		if (scan || link || roam) {
2002 			if (scan)
2003 				btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2004 			else
2005 				btc8821a1ant_action_wifi_not_connected_asso_auth(
2006 					btcoexist);
2007 		} else {
2008 			btc8821a1ant_action_wifi_not_connected(btcoexist);
2009 		}
2010 	} else {
2011 		/* wifi LPS/Busy */
2012 		btc8821a1ant_action_wifi_connected(btcoexist);
2013 	}
2014 }
2015 
btc8821a1ant_init_coex_dm(struct btc_coexist * btcoexist)2016 static void btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2017 {
2018 	/* force to reset coex mechanism
2019 	 * sw all off
2020 	 */
2021 	btc8821a1ant_sw_mechanism(btcoexist, false);
2022 
2023 	btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2024 }
2025 
btc8821a1ant_init_hw_config(struct btc_coexist * btcoexist,bool back_up,bool wifi_only)2026 static void btc8821a1ant_init_hw_config(struct btc_coexist *btcoexist,
2027 					bool back_up, bool wifi_only)
2028 {
2029 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2030 	u8 u1_tmp = 0;
2031 	bool wifi_under_5g = false;
2032 
2033 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2034 		"[BTCoex], 1Ant Init HW Config!!\n");
2035 
2036 	if (wifi_only)
2037 		return;
2038 
2039 	if (back_up) {
2040 		coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
2041 								      0x430);
2042 		coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
2043 								      0x434);
2044 		coex_dm->backup_retry_limit =
2045 			btcoexist->btc_read_2byte(btcoexist, 0x42a);
2046 		coex_dm->backup_ampdu_max_time =
2047 			btcoexist->btc_read_1byte(btcoexist, 0x456);
2048 	}
2049 
2050 	/* 0x790[5:0] = 0x5 */
2051 	u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
2052 	u1_tmp &= 0xc0;
2053 	u1_tmp |= 0x5;
2054 	btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp);
2055 
2056 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2057 
2058 	/* Antenna config */
2059 	if (wifi_under_5g)
2060 		btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2061 					  true, false);
2062 	else
2063 		btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2064 					  true, false);
2065 	/* PTA parameter */
2066 	btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2067 
2068 	/* Enable counter statistics
2069 	 * 0x76e[3] =1, WLAN_Act control by PTA
2070 	 */
2071 	btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
2072 	btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
2073 	btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2074 }
2075 
2076 /**************************************************************
2077  * extern function start with ex_btc8821a1ant_
2078  **************************************************************/
ex_btc8821a1ant_init_hwconfig(struct btc_coexist * btcoexist,bool wifionly)2079 void ex_btc8821a1ant_init_hwconfig(struct btc_coexist *btcoexist, bool wifionly)
2080 {
2081 	btc8821a1ant_init_hw_config(btcoexist, true, wifionly);
2082 	btcoexist->auto_report_1ant = true;
2083 }
2084 
ex_btc8821a1ant_init_coex_dm(struct btc_coexist * btcoexist)2085 void ex_btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2086 {
2087 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2088 
2089 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2090 		"[BTCoex], Coex Mechanism Init!!\n");
2091 
2092 	btcoexist->stop_coex_dm = false;
2093 
2094 	btc8821a1ant_init_coex_dm(btcoexist);
2095 
2096 	btc8821a1ant_query_bt_info(btcoexist);
2097 }
2098 
ex_btc8821a1ant_display_coex_info(struct btc_coexist * btcoexist,struct seq_file * m)2099 void ex_btc8821a1ant_display_coex_info(struct btc_coexist *btcoexist,
2100 				       struct seq_file *m)
2101 {
2102 	struct btc_board_info *board_info = &btcoexist->board_info;
2103 	struct btc_stack_info *stack_info = &btcoexist->stack_info;
2104 	struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2105 	u8 u1_tmp[4], i, bt_info_ext, ps_tdma_case = 0;
2106 	u16 u2_tmp[4];
2107 	u32 u4_tmp[4];
2108 	bool roam = false, scan = false, link = false, wifi_under_5g = false;
2109 	bool bt_hs_on = false, wifi_busy = false;
2110 	long wifi_rssi = 0, bt_hs_rssi = 0;
2111 	u32 wifi_bw, wifi_traffic_dir;
2112 	u8 wifi_dot11_chnl, wifi_hs_chnl;
2113 	u32 fw_ver = 0, bt_patch_ver = 0;
2114 
2115 	seq_puts(m, "\n ============[BT Coexist info]============");
2116 
2117 	if (btcoexist->manual_control) {
2118 		seq_puts(m, "\n ============[Under Manual Control]============");
2119 		seq_puts(m, "\n ==========================================");
2120 	}
2121 	if (btcoexist->stop_coex_dm) {
2122 		seq_puts(m, "\n ============[Coex is STOPPED]============");
2123 		seq_puts(m, "\n ==========================================");
2124 	}
2125 
2126 	seq_printf(m, "\n %-35s = %d/ %d/ %d",
2127 		   "Ant PG Num/ Ant Mech/ Ant Pos:",
2128 		   board_info->pg_ant_num,
2129 		   board_info->btdm_ant_num,
2130 		   board_info->btdm_ant_pos);
2131 
2132 	seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver",
2133 		   ((stack_info->profile_notified) ? "Yes" : "No"),
2134 		   stack_info->hci_version);
2135 
2136 	btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
2137 			   &bt_patch_ver);
2138 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2139 	seq_printf(m, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2140 		   "CoexVer/ FwVer/ PatchVer",
2141 		   glcoex_ver_date_8821a_1ant,
2142 		   glcoex_ver_8821a_1ant,
2143 		   fw_ver, bt_patch_ver,
2144 		   bt_patch_ver);
2145 
2146 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION,
2147 			   &bt_hs_on);
2148 	btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2149 			   &wifi_dot11_chnl);
2150 	btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL,
2151 			   &wifi_hs_chnl);
2152 	seq_printf(m, "\n %-35s = %d / %d(%d)",
2153 		   "Dot11 channel / HsChnl(HsMode)",
2154 		   wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
2155 
2156 	seq_printf(m, "\n %-35s = %3ph ",
2157 		   "H2C Wifi inform bt chnl Info",
2158 		   coex_dm->wifi_chnl_info);
2159 
2160 	btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
2161 	btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
2162 	seq_printf(m, "\n %-35s = %d/ %d", "Wifi rssi/ HS rssi",
2163 		   (int)wifi_rssi, (int)bt_hs_rssi);
2164 
2165 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2166 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2167 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2168 	seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
2169 		   link, roam, scan);
2170 
2171 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
2172 			   &wifi_under_5g);
2173 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2174 			   &wifi_bw);
2175 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
2176 			   &wifi_busy);
2177 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
2178 			   &wifi_traffic_dir);
2179 	seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status",
2180 		   (wifi_under_5g ? "5G" : "2.4G"),
2181 		   ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
2182 		   (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
2183 		   ((!wifi_busy) ? "idle" :
2184 		   ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
2185 		   "uplink" : "downlink")));
2186 	seq_printf(m, "\n %-35s = [%s/ %d/ %d] ",
2187 		   "BT [status/ rssi/ retryCnt]",
2188 		   ((coex_sta->bt_disabled) ? ("disabled") :
2189 		   ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
2190 		   ((BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2191 		     coex_dm->bt_status) ?
2192 		   "non-connected idle" :
2193 		   ((BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
2194 		     coex_dm->bt_status) ?
2195 		   "connected-idle" : "busy")))),
2196 		   coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
2197 
2198 	seq_printf(m, "\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
2199 		   bt_link_info->sco_exist,
2200 		   bt_link_info->hid_exist,
2201 		   bt_link_info->pan_exist,
2202 		   bt_link_info->a2dp_exist);
2203 	btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO, m);
2204 
2205 	bt_info_ext = coex_sta->bt_info_ext;
2206 	seq_printf(m, "\n %-35s = %s",
2207 		   "BT Info A2DP rate",
2208 		   (bt_info_ext & BIT0) ?
2209 		   "Basic rate" : "EDR rate");
2210 
2211 	for (i = 0; i < BT_INFO_SRC_8821A_1ANT_MAX; i++) {
2212 		if (coex_sta->bt_info_c2h_cnt[i]) {
2213 			seq_printf(m, "\n %-35s = %7ph(%d)",
2214 				   glbt_info_src_8821a_1ant[i],
2215 				   coex_sta->bt_info_c2h[i],
2216 				   coex_sta->bt_info_c2h_cnt[i]);
2217 		}
2218 	}
2219 	seq_printf(m, "\n %-35s = %s/%s, (0x%x/0x%x)",
2220 		   "PS state, IPS/LPS, (lps/rpwm)",
2221 		   ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
2222 		   ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")),
2223 		   btcoexist->bt_info.lps_val,
2224 		   btcoexist->bt_info.rpwm_val);
2225 	btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m);
2226 
2227 	if (!btcoexist->manual_control) {
2228 		/* Sw mechanism*/
2229 		seq_printf(m, "\n %-35s",
2230 			   "============[Sw mechanism]============");
2231 
2232 		seq_printf(m, "\n %-35s = %d", "SM[LowPenaltyRA]",
2233 			   coex_dm->cur_low_penalty_ra);
2234 
2235 		seq_printf(m, "\n %-35s = %s/ %s/ %d ",
2236 			   "DelBA/ BtCtrlAgg/ AggSize",
2237 			   (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"),
2238 			   (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"),
2239 			   btcoexist->bt_info.agg_buf_size);
2240 		seq_printf(m, "\n %-35s = 0x%x ", "Rate Mask",
2241 			   btcoexist->bt_info.ra_mask);
2242 
2243 		/* Fw mechanism */
2244 		seq_printf(m, "\n %-35s",
2245 			   "============[Fw mechanism]============");
2246 
2247 		ps_tdma_case = coex_dm->cur_ps_tdma;
2248 		seq_printf(m, "\n %-35s = %5ph case-%d (auto:%d)",
2249 			   "PS TDMA",
2250 			   coex_dm->ps_tdma_para,
2251 			   ps_tdma_case,
2252 			   coex_dm->auto_tdma_adjust);
2253 
2254 		seq_printf(m, "\n %-35s = 0x%x ",
2255 			   "Latest error condition(should be 0)",
2256 			   coex_dm->error_condition);
2257 
2258 		seq_printf(m, "\n %-35s = %d ", "IgnWlanAct",
2259 			   coex_dm->cur_ignore_wlan_act);
2260 	}
2261 
2262 	/* Hw setting */
2263 	seq_printf(m, "\n %-35s", "============[Hw setting]============");
2264 
2265 	seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2266 		   "backup ARFR1/ARFR2/RL/AMaxTime",
2267 		   coex_dm->backup_arfr_cnt1,
2268 		   coex_dm->backup_arfr_cnt2,
2269 		   coex_dm->backup_retry_limit,
2270 		   coex_dm->backup_ampdu_max_time);
2271 
2272 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
2273 	u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
2274 	u2_tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
2275 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
2276 	seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2277 		   "0x430/0x434/0x42a/0x456",
2278 		   u4_tmp[0], u4_tmp[1], u2_tmp[0], u1_tmp[0]);
2279 
2280 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
2281 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc58);
2282 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x778/ 0xc58[29:25]",
2283 		   u1_tmp[0], (u4_tmp[0] & 0x3e000000) >> 25);
2284 
2285 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
2286 	seq_printf(m, "\n %-35s = 0x%x", "0x8db[6:5]",
2287 		   ((u1_tmp[0] & 0x60) >> 5));
2288 
2289 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x975);
2290 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
2291 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2292 		   "0xcb4[29:28]/0xcb4[7:0]/0x974[9:8]",
2293 		   (u4_tmp[0] & 0x30000000) >> 28,
2294 		    u4_tmp[0] & 0xff,
2295 		    u1_tmp[0] & 0x3);
2296 
2297 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
2298 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2299 	u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x64);
2300 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x",
2301 		   "0x40/0x4c[24:23]/0x64[0]",
2302 		   u1_tmp[0], ((u4_tmp[0] & 0x01800000) >> 23),
2303 		   u1_tmp[1] & 0x1);
2304 
2305 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
2306 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
2307 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522",
2308 		   u4_tmp[0], u1_tmp[0]);
2309 
2310 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
2311 	seq_printf(m, "\n %-35s = 0x%x", "0xc50(dig)",
2312 		   u4_tmp[0] & 0xff);
2313 
2314 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
2315 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5d);
2316 	u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
2317 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "OFDM-FA/ CCK-FA",
2318 		   u4_tmp[0], (u1_tmp[0] << 8) + u1_tmp[1]);
2319 
2320 	u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
2321 	u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
2322 	u4_tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
2323 	u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
2324 	seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2325 		   "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
2326 		   u4_tmp[0], u4_tmp[1], u4_tmp[2], u1_tmp[0]);
2327 
2328 	seq_printf(m, "\n %-35s = %d/ %d", "0x770(high-pri rx/tx)",
2329 		   coex_sta->high_priority_rx, coex_sta->high_priority_tx);
2330 	seq_printf(m, "\n %-35s = %d/ %d", "0x774(low-pri rx/tx)",
2331 		   coex_sta->low_priority_rx, coex_sta->low_priority_tx);
2332 	if (btcoexist->auto_report_1ant)
2333 		btc8821a1ant_monitor_bt_ctr(btcoexist);
2334 	btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m);
2335 }
2336 
ex_btc8821a1ant_ips_notify(struct btc_coexist * btcoexist,u8 type)2337 void ex_btc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2338 {
2339 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2340 	bool wifi_under_5g = false;
2341 
2342 	if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2343 		return;
2344 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2345 	if (wifi_under_5g) {
2346 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2347 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2348 		btc8821a1ant_coex_under_5g(btcoexist);
2349 		return;
2350 	}
2351 
2352 	if (BTC_IPS_ENTER == type) {
2353 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2354 			"[BTCoex], IPS ENTER notify\n");
2355 		coex_sta->under_ips = true;
2356 		btc8821a1ant_set_ant_path(btcoexist,
2357 					  BTC_ANT_PATH_BT, false, true);
2358 		/* set PTA control */
2359 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2360 		btc8821a1ant_coex_table_with_type(btcoexist,
2361 						  NORMAL_EXEC, 0);
2362 	} else if (BTC_IPS_LEAVE == type) {
2363 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2364 			"[BTCoex], IPS LEAVE notify\n");
2365 		coex_sta->under_ips = false;
2366 
2367 		btc8821a1ant_init_hw_config(btcoexist, false, false);
2368 		btc8821a1ant_init_coex_dm(btcoexist);
2369 		btc8821a1ant_query_bt_info(btcoexist);
2370 	}
2371 }
2372 
ex_btc8821a1ant_lps_notify(struct btc_coexist * btcoexist,u8 type)2373 void ex_btc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2374 {
2375 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2376 
2377 	if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2378 		return;
2379 
2380 	if (BTC_LPS_ENABLE == type) {
2381 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2382 			"[BTCoex], LPS ENABLE notify\n");
2383 		coex_sta->under_lps = true;
2384 	} else if (BTC_LPS_DISABLE == type) {
2385 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2386 			"[BTCoex], LPS DISABLE notify\n");
2387 		coex_sta->under_lps = false;
2388 	}
2389 }
2390 
ex_btc8821a1ant_scan_notify(struct btc_coexist * btcoexist,u8 type)2391 void ex_btc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2392 {
2393 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2394 	bool wifi_connected = false, bt_hs_on = false;
2395 	bool bt_ctrl_agg_buf_size = false;
2396 	bool wifi_under_5g = false;
2397 	u32 wifi_link_status = 0;
2398 	u32 num_of_wifi_link = 0;
2399 	u8 agg_buf_size = 5;
2400 
2401 	if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2402 		return;
2403 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2404 	if (wifi_under_5g) {
2405 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2406 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2407 		btc8821a1ant_coex_under_5g(btcoexist);
2408 		return;
2409 	}
2410 
2411 	if (type == BTC_SCAN_START) {
2412 		coex_sta->wifi_is_high_pri_task = true;
2413 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2414 			"[BTCoex], SCAN START notify\n");
2415 
2416 		/* Force antenna setup for no scan result issue */
2417 		btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2418 	} else {
2419 		coex_sta->wifi_is_high_pri_task = false;
2420 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2421 			"[BTCoex], SCAN FINISH notify\n");
2422 	}
2423 
2424 	if (coex_sta->bt_disabled)
2425 		return;
2426 
2427 	btcoexist->btc_get(btcoexist,
2428 		 BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2429 	btcoexist->btc_get(btcoexist,
2430 		 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2431 
2432 	btc8821a1ant_query_bt_info(btcoexist);
2433 
2434 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2435 			   &wifi_link_status);
2436 	num_of_wifi_link = wifi_link_status >> 16;
2437 	if (num_of_wifi_link >= 2) {
2438 		btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2439 		btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2440 					bt_ctrl_agg_buf_size, agg_buf_size);
2441 		btc8821a1ant_action_wifi_multi_port(btcoexist);
2442 		return;
2443 	}
2444 
2445 	if (coex_sta->c2h_bt_inquiry_page) {
2446 		btc8821a1ant_action_bt_inquiry(btcoexist);
2447 		return;
2448 	} else if (bt_hs_on) {
2449 		btc8821a1ant_action_hs(btcoexist);
2450 		return;
2451 	}
2452 
2453 	if (BTC_SCAN_START == type) {
2454 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2455 			"[BTCoex], SCAN START notify\n");
2456 		if (!wifi_connected) {
2457 			/* non-connected scan */
2458 			btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2459 		} else {
2460 			/* wifi is connected */
2461 			btc8821a1ant_action_wifi_connected_scan(btcoexist);
2462 		}
2463 	} else if (BTC_SCAN_FINISH == type) {
2464 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2465 			"[BTCoex], SCAN FINISH notify\n");
2466 		if (!wifi_connected) {
2467 			/* non-connected scan */
2468 			btc8821a1ant_action_wifi_not_connected(btcoexist);
2469 		} else {
2470 			btc8821a1ant_action_wifi_connected(btcoexist);
2471 		}
2472 	}
2473 }
2474 
ex_btc8821a1ant_connect_notify(struct btc_coexist * btcoexist,u8 type)2475 void ex_btc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2476 {
2477 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2478 	bool wifi_connected = false, bt_hs_on = false;
2479 	u32 wifi_link_status = 0;
2480 	u32 num_of_wifi_link = 0;
2481 	bool bt_ctrl_agg_buf_size = false;
2482 	bool wifi_under_5g = false;
2483 	u8 agg_buf_size = 5;
2484 
2485 	if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2486 	    coex_sta->bt_disabled)
2487 		return;
2488 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2489 	if (wifi_under_5g) {
2490 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2491 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2492 		btc8821a1ant_coex_under_5g(btcoexist);
2493 		return;
2494 	}
2495 
2496 	if (type == BTC_ASSOCIATE_START) {
2497 		coex_sta->wifi_is_high_pri_task = true;
2498 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2499 			"[BTCoex], CONNECT START notify\n");
2500 		coex_dm->arp_cnt = 0;
2501 	} else {
2502 		coex_sta->wifi_is_high_pri_task = false;
2503 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2504 			"[BTCoex], CONNECT FINISH notify\n");
2505 		coex_dm->arp_cnt = 0;
2506 	}
2507 
2508 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2509 			   &wifi_link_status);
2510 	num_of_wifi_link = wifi_link_status >> 16;
2511 	if (num_of_wifi_link >= 2) {
2512 		btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2513 		btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2514 					bt_ctrl_agg_buf_size, agg_buf_size);
2515 		btc8821a1ant_action_wifi_multi_port(btcoexist);
2516 		return;
2517 	}
2518 
2519 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2520 	if (coex_sta->c2h_bt_inquiry_page) {
2521 		btc8821a1ant_action_bt_inquiry(btcoexist);
2522 		return;
2523 	} else if (bt_hs_on) {
2524 		btc8821a1ant_action_hs(btcoexist);
2525 		return;
2526 	}
2527 
2528 	if (BTC_ASSOCIATE_START == type) {
2529 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2530 			"[BTCoex], CONNECT START notify\n");
2531 		btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2532 	} else if (BTC_ASSOCIATE_FINISH == type) {
2533 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2534 			"[BTCoex], CONNECT FINISH notify\n");
2535 
2536 		btcoexist->btc_get(btcoexist,
2537 			 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2538 		if (!wifi_connected) {
2539 			/* non-connected scan */
2540 			btc8821a1ant_action_wifi_not_connected(btcoexist);
2541 		} else {
2542 			btc8821a1ant_action_wifi_connected(btcoexist);
2543 		}
2544 	}
2545 }
2546 
ex_btc8821a1ant_media_status_notify(struct btc_coexist * btcoexist,u8 type)2547 void ex_btc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
2548 					 u8 type)
2549 {
2550 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2551 	u8 h2c_parameter[3] = {0};
2552 	u32 wifi_bw;
2553 	u8 wifi_central_chnl;
2554 	bool wifi_under_5g = false;
2555 
2556 	if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2557 	    coex_sta->bt_disabled)
2558 		return;
2559 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2560 	if (wifi_under_5g) {
2561 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2562 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2563 		btc8821a1ant_coex_under_5g(btcoexist);
2564 		return;
2565 	}
2566 
2567 	if (BTC_MEDIA_CONNECT == type) {
2568 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2569 			"[BTCoex], MEDIA connect notify\n");
2570 	} else {
2571 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2572 			"[BTCoex], MEDIA disconnect notify\n");
2573 		coex_dm->arp_cnt = 0;
2574 	}
2575 
2576 	/* only 2.4G we need to inform bt the chnl mask */
2577 	btcoexist->btc_get(btcoexist,
2578 			   BTC_GET_U1_WIFI_CENTRAL_CHNL,
2579 			   &wifi_central_chnl);
2580 	if ((type == BTC_MEDIA_CONNECT) &&
2581 	    (wifi_central_chnl <= 14)) {
2582 		h2c_parameter[0] = 0x0;
2583 		h2c_parameter[1] = wifi_central_chnl;
2584 		btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2585 		if (wifi_bw == BTC_WIFI_BW_HT40)
2586 			h2c_parameter[2] = 0x30;
2587 		else
2588 			h2c_parameter[2] = 0x20;
2589 	}
2590 
2591 	coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
2592 	coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
2593 	coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
2594 
2595 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2596 		"[BTCoex], FW write 0x66 = 0x%x\n",
2597 		h2c_parameter[0] << 16 |
2598 		h2c_parameter[1] << 8 |
2599 		h2c_parameter[2]);
2600 
2601 	btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
2602 }
2603 
ex_btc8821a1ant_special_packet_notify(struct btc_coexist * btcoexist,u8 type)2604 void ex_btc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist,
2605 					   u8 type)
2606 {
2607 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2608 	bool bt_hs_on = false;
2609 	bool bt_ctrl_agg_buf_size = false;
2610 	bool wifi_under_5g = false;
2611 	u32 wifi_link_status = 0;
2612 	u32 num_of_wifi_link = 0;
2613 	u8 agg_buf_size = 5;
2614 
2615 	if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2616 	    coex_sta->bt_disabled)
2617 		return;
2618 
2619 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2620 	if (wifi_under_5g) {
2621 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2622 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2623 		btc8821a1ant_coex_under_5g(btcoexist);
2624 		return;
2625 	}
2626 
2627 	if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2628 	    type == BTC_PACKET_ARP) {
2629 		coex_sta->wifi_is_high_pri_task = true;
2630 
2631 		if (type == BTC_PACKET_ARP) {
2632 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2633 				"[BTCoex], specific Packet ARP notify\n");
2634 		} else {
2635 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2636 				"[BTCoex], specific Packet DHCP or EAPOL notify\n");
2637 		}
2638 	} else {
2639 		coex_sta->wifi_is_high_pri_task = false;
2640 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2641 			"[BTCoex], specific Packet [Type = %d] notify\n",
2642 			type);
2643 	}
2644 
2645 	coex_sta->special_pkt_period_cnt = 0;
2646 
2647 	btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2648 			   &wifi_link_status);
2649 	num_of_wifi_link = wifi_link_status >> 16;
2650 	if (num_of_wifi_link >= 2) {
2651 		btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2652 		btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2653 					bt_ctrl_agg_buf_size, agg_buf_size);
2654 		btc8821a1ant_action_wifi_multi_port(btcoexist);
2655 		return;
2656 	}
2657 
2658 	btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2659 	if (coex_sta->c2h_bt_inquiry_page) {
2660 		btc8821a1ant_action_bt_inquiry(btcoexist);
2661 		return;
2662 	} else if (bt_hs_on) {
2663 		btc8821a1ant_action_hs(btcoexist);
2664 		return;
2665 	}
2666 
2667 	if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2668 	    type == BTC_PACKET_ARP) {
2669 		if (type == BTC_PACKET_ARP) {
2670 			coex_dm->arp_cnt++;
2671 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2672 				"[BTCoex], ARP Packet Count = %d\n",
2673 				coex_dm->arp_cnt);
2674 			if (coex_dm->arp_cnt >= 10)
2675 				/* if APR PKT > 10 after connect, do not go to
2676 				 * btc8821a1ant_act_wifi_conn_sp_pkt
2677 				 */
2678 				return;
2679 		}
2680 
2681 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2682 			"[BTCoex], special Packet(%d) notify\n", type);
2683 		btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
2684 	}
2685 }
2686 
ex_btc8821a1ant_bt_info_notify(struct btc_coexist * btcoexist,u8 * tmp_buf,u8 length)2687 void ex_btc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
2688 				    u8 *tmp_buf, u8 length)
2689 {
2690 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2691 	u8 i;
2692 	u8 bt_info = 0;
2693 	u8 rsp_source = 0;
2694 	bool wifi_connected = false;
2695 	bool bt_busy = false;
2696 	bool wifi_under_5g = false;
2697 
2698 	coex_sta->c2h_bt_info_req_sent = false;
2699 
2700 	btcoexist->btc_get(btcoexist,
2701 		 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2702 
2703 	rsp_source = tmp_buf[0] & 0xf;
2704 	if (rsp_source >= BT_INFO_SRC_8821A_1ANT_MAX)
2705 		rsp_source = BT_INFO_SRC_8821A_1ANT_WIFI_FW;
2706 	coex_sta->bt_info_c2h_cnt[rsp_source]++;
2707 
2708 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2709 		"[BTCoex], Bt info[%d], length = %d, hex data = [",
2710 		rsp_source, length);
2711 	for (i = 0; i < length; i++) {
2712 		coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
2713 		if (i == 1)
2714 			bt_info = tmp_buf[i];
2715 		if (i == length - 1) {
2716 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2717 				"0x%02x]\n", tmp_buf[i]);
2718 		} else {
2719 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2720 				"0x%02x, ", tmp_buf[i]);
2721 		}
2722 	}
2723 
2724 	if (BT_INFO_SRC_8821A_1ANT_WIFI_FW != rsp_source) {
2725 		/* [3:0] */
2726 		coex_sta->bt_retry_cnt =
2727 			coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
2728 
2729 		coex_sta->bt_rssi =
2730 			coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
2731 
2732 		coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
2733 
2734 		coex_sta->bt_tx_rx_mask =
2735 			(coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
2736 		btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
2737 				   &coex_sta->bt_tx_rx_mask);
2738 		if (!coex_sta->bt_tx_rx_mask) {
2739 			/* BT into is responded by BT FW and BT RF REG 0x3C !=
2740 			 * 0x15 => Need to switch BT TRx Mask
2741 			 */
2742 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2743 				"[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
2744 			btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
2745 						  0x3c, 0x15);
2746 		}
2747 
2748 		/* Here we need to resend some wifi info to BT
2749 		 * because bt is reset and lost the info
2750 		 */
2751 		if (coex_sta->bt_info_ext & BIT1) {
2752 			rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2753 				"[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
2754 			btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2755 					   &wifi_connected);
2756 			if (wifi_connected) {
2757 				ex_btc8821a1ant_media_status_notify(btcoexist,
2758 							       BTC_MEDIA_CONNECT);
2759 			} else {
2760 				ex_btc8821a1ant_media_status_notify(btcoexist,
2761 							       BTC_MEDIA_DISCONNECT);
2762 			}
2763 		}
2764 
2765 		if ((coex_sta->bt_info_ext & BIT3) && !wifi_under_5g) {
2766 			if (!btcoexist->manual_control &&
2767 			    !btcoexist->stop_coex_dm) {
2768 				rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2769 					"[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
2770 				btc8821a1ant_ignore_wlan_act(btcoexist,
2771 							     FORCE_EXEC,
2772 							     false);
2773 			}
2774 		}
2775 	}
2776 
2777 	/* check BIT2 first ==> check if bt is under inquiry or page scan */
2778 	if (bt_info & BT_INFO_8821A_1ANT_B_INQ_PAGE)
2779 		coex_sta->c2h_bt_inquiry_page = true;
2780 	else
2781 		coex_sta->c2h_bt_inquiry_page = false;
2782 
2783 	/* set link exist status */
2784 	if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2785 		coex_sta->bt_link_exist = false;
2786 		coex_sta->pan_exist = false;
2787 		coex_sta->a2dp_exist = false;
2788 		coex_sta->hid_exist = false;
2789 		coex_sta->sco_exist = false;
2790 	} else {
2791 		/* connection exists */
2792 		coex_sta->bt_link_exist = true;
2793 		if (bt_info & BT_INFO_8821A_1ANT_B_FTP)
2794 			coex_sta->pan_exist = true;
2795 		else
2796 			coex_sta->pan_exist = false;
2797 		if (bt_info & BT_INFO_8821A_1ANT_B_A2DP)
2798 			coex_sta->a2dp_exist = true;
2799 		else
2800 			coex_sta->a2dp_exist = false;
2801 		if (bt_info & BT_INFO_8821A_1ANT_B_HID)
2802 			coex_sta->hid_exist = true;
2803 		else
2804 			coex_sta->hid_exist = false;
2805 		if (bt_info & BT_INFO_8821A_1ANT_B_SCO_ESCO)
2806 			coex_sta->sco_exist = true;
2807 		else
2808 			coex_sta->sco_exist = false;
2809 	}
2810 
2811 	btc8821a1ant_update_bt_link_info(btcoexist);
2812 
2813 	/* mask profile bit for connect-ilde identification
2814 	 * (for CSR case: A2DP idle --> 0x41)
2815 	 */
2816 	bt_info = bt_info & 0x1f;
2817 
2818 	if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2819 		coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
2820 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2821 			"[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
2822 	} else if (bt_info == BT_INFO_8821A_1ANT_B_CONNECTION) {
2823 		/* connection exists but no busy */
2824 		coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE;
2825 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2826 			"[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
2827 	} else if ((bt_info&BT_INFO_8821A_1ANT_B_SCO_ESCO) ||
2828 		(bt_info & BT_INFO_8821A_1ANT_B_SCO_BUSY)) {
2829 		coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_SCO_BUSY;
2830 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2831 			"[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
2832 	} else if (bt_info & BT_INFO_8821A_1ANT_B_ACL_BUSY) {
2833 		if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
2834 			coex_dm->auto_tdma_adjust = false;
2835 		coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_ACL_BUSY;
2836 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2837 			"[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
2838 	} else {
2839 		coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_MAX;
2840 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2841 			"[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
2842 	}
2843 
2844 	if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
2845 	    (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2846 	    (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
2847 		bt_busy = true;
2848 	else
2849 		bt_busy = false;
2850 	btcoexist->btc_set(btcoexist,
2851 			   BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2852 
2853 	btc8821a1ant_run_coexist_mechanism(btcoexist);
2854 }
2855 
ex_btc8821a1ant_halt_notify(struct btc_coexist * btcoexist)2856 void ex_btc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
2857 {
2858 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2859 	bool wifi_under_5g = false;
2860 
2861 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2862 		"[BTCoex], Halt notify\n");
2863 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2864 	if (wifi_under_5g) {
2865 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2866 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2867 		btc8821a1ant_coex_under_5g(btcoexist);
2868 		return;
2869 	}
2870 
2871 
2872 	btcoexist->stop_coex_dm = true;
2873 
2874 	btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, true);
2875 	btc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
2876 
2877 	btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2878 	btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
2879 
2880 	ex_btc8821a1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
2881 }
2882 
ex_btc8821a1ant_pnp_notify(struct btc_coexist * btcoexist,u8 pnp_state)2883 void ex_btc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
2884 {
2885 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2886 	bool wifi_under_5g = false;
2887 
2888 	btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2889 	if (wifi_under_5g) {
2890 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2891 			"[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2892 		btc8821a1ant_coex_under_5g(btcoexist);
2893 		return;
2894 	}
2895 
2896 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2897 		"[BTCoex], Pnp notify\n");
2898 
2899 	if (BTC_WIFI_PNP_SLEEP == pnp_state) {
2900 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2901 			"[BTCoex], Pnp notify to SLEEP\n");
2902 		/* BT should clear UnderIPS/UnderLPS state to avoid mismatch
2903 		 * state after wakeup.
2904 		 */
2905 		coex_sta->under_ips = false;
2906 		coex_sta->under_lps = false;
2907 		btcoexist->stop_coex_dm = true;
2908 		btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
2909 					      0x0, 0x0);
2910 		btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2911 		btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
2912 		btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false,
2913 					  true);
2914 	} else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
2915 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2916 			"[BTCoex], Pnp notify to WAKE UP\n");
2917 		btcoexist->stop_coex_dm = false;
2918 		btc8821a1ant_init_hw_config(btcoexist, false, false);
2919 		btc8821a1ant_init_coex_dm(btcoexist);
2920 		btc8821a1ant_query_bt_info(btcoexist);
2921 	}
2922 }
2923 
ex_btc8821a1ant_periodical(struct btc_coexist * btcoexist)2924 void ex_btc8821a1ant_periodical(struct btc_coexist *btcoexist)
2925 {
2926 	struct rtl_priv *rtlpriv = btcoexist->adapter;
2927 	static u8 dis_ver_info_cnt;
2928 	u32 fw_ver = 0, bt_patch_ver = 0;
2929 	struct btc_board_info *board_info = &btcoexist->board_info;
2930 	struct btc_stack_info *stack_info = &btcoexist->stack_info;
2931 
2932 	rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2933 		"[BTCoex], ==========================Periodical===========================\n");
2934 
2935 	if (dis_ver_info_cnt <= 5) {
2936 		dis_ver_info_cnt += 1;
2937 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2938 			"[BTCoex], ****************************************************************\n");
2939 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2940 			"[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
2941 			board_info->pg_ant_num,
2942 			board_info->btdm_ant_num,
2943 			board_info->btdm_ant_pos);
2944 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2945 			"[BTCoex], BT stack/ hci ext ver = %s / %d\n",
2946 			stack_info->profile_notified ? "Yes" : "No",
2947 			stack_info->hci_version);
2948 		btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
2949 				   &bt_patch_ver);
2950 		btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2951 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2952 			"[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
2953 			glcoex_ver_date_8821a_1ant,
2954 			glcoex_ver_8821a_1ant,
2955 			fw_ver, bt_patch_ver,
2956 			bt_patch_ver);
2957 		rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2958 			"[BTCoex], ****************************************************************\n");
2959 	}
2960 
2961 	if (!btcoexist->auto_report_1ant) {
2962 		btc8821a1ant_query_bt_info(btcoexist);
2963 		btc8821a1ant_monitor_bt_ctr(btcoexist);
2964 	} else {
2965 		coex_sta->special_pkt_period_cnt++;
2966 	}
2967 }
2968