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 **************************************************************/ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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) */ 1391 static void btc8821a1ant_action_sco(struct btc_coexist *btcoexist) 1392 { 1393 btc8821a1ant_sw_mechanism(btcoexist, true); 1394 } 1395 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) */ 1402 static void btc8821a1ant_action_a2dp(struct btc_coexist *btcoexist) 1403 { 1404 btc8821a1ant_sw_mechanism(btcoexist, false); 1405 } 1406 1407 static void btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist) 1408 { 1409 btc8821a1ant_sw_mechanism(btcoexist, false); 1410 } 1411 1412 static void btc8821a1ant_action_pan_edr(struct btc_coexist *btcoexist) 1413 { 1414 btc8821a1ant_sw_mechanism(btcoexist, false); 1415 } 1416 1417 /* PAN(HS) only */ 1418 static void btc8821a1ant_action_pan_hs(struct btc_coexist *btcoexist) 1419 { 1420 btc8821a1ant_sw_mechanism(btcoexist, false); 1421 } 1422 1423 /* PAN(EDR)+A2DP */ 1424 static void btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist) 1425 { 1426 btc8821a1ant_sw_mechanism(btcoexist, false); 1427 } 1428 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) */ 1435 static void btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist) 1436 { 1437 btc8821a1ant_sw_mechanism(btcoexist, true); 1438 } 1439 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 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 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 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 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 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 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 */ 1604 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 1605 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 1606 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1607 true, 14); 1608 coex_dm->auto_tdma_adjust = false; 1609 } else { 1610 /*for low BT RSSI*/ 1611 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1612 true, 14); 1613 coex_dm->auto_tdma_adjust = false; 1614 } 1615 1616 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1); 1617 } else if ((bt_link_info->pan_only) || 1618 (bt_link_info->hid_exist && bt_link_info->pan_exist)) { 1619 /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */ 1620 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 1621 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6); 1622 coex_dm->auto_tdma_adjust = false; 1623 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) || 1624 (bt_link_info->hid_exist && bt_link_info->a2dp_exist && 1625 bt_link_info->pan_exist)) { 1626 /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */ 1627 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 43); 1628 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1); 1629 coex_dm->auto_tdma_adjust = false; 1630 } else { 1631 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 1632 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1); 1633 coex_dm->auto_tdma_adjust = false; 1634 } 1635 } 1636 1637 static 1638 void btc8821a1ant_action_wifi_not_connected(struct btc_coexist *btcoexist) 1639 { 1640 /* power save state */ 1641 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0); 1642 1643 /* tdma and coex table */ 1644 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1645 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0); 1646 } 1647 1648 static void btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist *btcoexist) 1649 { 1650 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1651 1652 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0); 1653 1654 /* tdma and coex table */ 1655 if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) { 1656 if (bt_link_info->a2dp_exist) { 1657 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1658 btc8821a1ant_coex_table_with_type(btcoexist, 1659 NORMAL_EXEC, 1); 1660 } else if (bt_link_info->a2dp_exist && 1661 bt_link_info->pan_exist) { 1662 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22); 1663 btc8821a1ant_coex_table_with_type(btcoexist, 1664 NORMAL_EXEC, 4); 1665 } else { 1666 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20); 1667 btc8821a1ant_coex_table_with_type(btcoexist, 1668 NORMAL_EXEC, 4); 1669 } 1670 } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) || 1671 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == 1672 coex_dm->bt_status)) { 1673 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist, 1674 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN); 1675 } else { 1676 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1677 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1678 } 1679 } 1680 1681 static 1682 void btc8821a1ant_action_wifi_connected_scan(struct btc_coexist *btcoexist) 1683 { 1684 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1685 1686 /* power save state */ 1687 btc8821a1ant_power_save_state(btcoexist, 1688 BTC_PS_WIFI_NATIVE, 0x0, 0x0); 1689 1690 /* tdma and coex table */ 1691 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) { 1692 if (bt_link_info->a2dp_exist) { 1693 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1694 btc8821a1ant_coex_table_with_type(btcoexist, 1695 NORMAL_EXEC, 1); 1696 } else { 1697 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20); 1698 btc8821a1ant_coex_table_with_type(btcoexist, 1699 NORMAL_EXEC, 4); 1700 } 1701 } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) || 1702 (coex_dm->bt_status == 1703 BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY)) { 1704 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist, 1705 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN); 1706 } else { 1707 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1708 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1709 } 1710 } 1711 1712 static void btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist *btcoexist) 1713 { 1714 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1715 1716 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1717 0x0, 0x0); 1718 1719 /* tdma and coex table */ 1720 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) || 1721 (bt_link_info->a2dp_exist)) { 1722 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32); 1723 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1724 } 1725 1726 if ((bt_link_info->hid_exist) && (bt_link_info->a2dp_exist)) { 1727 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1728 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1); 1729 } else if (bt_link_info->pan_exist) { 1730 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20); 1731 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1732 } else { 1733 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1734 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1735 } 1736 } 1737 1738 static void btc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist) 1739 { 1740 struct rtl_priv *rtlpriv = btcoexist->adapter; 1741 bool wifi_busy = false; 1742 bool scan = false, link = false, roam = false; 1743 bool under_4way = false; 1744 bool ap_enable = false; 1745 1746 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1747 "[BTCoex], CoexForWifiConnect()===>\n"); 1748 1749 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 1750 &under_4way); 1751 if (under_4way) { 1752 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist); 1753 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1754 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n"); 1755 return; 1756 } 1757 1758 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 1759 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 1760 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 1761 if (scan || link || roam) { 1762 if (scan) 1763 btc8821a1ant_action_wifi_connected_scan(btcoexist); 1764 else 1765 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist); 1766 1767 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1768 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n"); 1769 return; 1770 } 1771 1772 /* power save state*/ 1773 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, 1774 &ap_enable); 1775 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 1776 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == 1777 coex_dm->bt_status && !ap_enable && 1778 !btcoexist->bt_link_info.hid_only) { 1779 if (!wifi_busy && btcoexist->bt_link_info.a2dp_only) 1780 /* A2DP */ 1781 btc8821a1ant_power_save_state(btcoexist, 1782 BTC_PS_WIFI_NATIVE, 0x0, 0x0); 1783 else 1784 btc8821a1ant_power_save_state(btcoexist, BTC_PS_LPS_ON, 1785 0x50, 0x4); 1786 } else { 1787 btc8821a1ant_power_save_state(btcoexist, 1788 BTC_PS_WIFI_NATIVE, 1789 0x0, 0x0); 1790 } 1791 1792 /* tdma and coex table */ 1793 if (!wifi_busy) { 1794 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) { 1795 btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist, 1796 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE); 1797 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY == 1798 coex_dm->bt_status) || 1799 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == 1800 coex_dm->bt_status)) { 1801 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist, 1802 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE); 1803 } else { 1804 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1805 btc8821a1ant_coex_table_with_type(btcoexist, 1806 NORMAL_EXEC, 2); 1807 } 1808 } else { 1809 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) { 1810 btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist, 1811 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY); 1812 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY == 1813 coex_dm->bt_status) || 1814 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == 1815 coex_dm->bt_status)) { 1816 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist, 1817 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY); 1818 } else { 1819 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1820 btc8821a1ant_coex_table_with_type(btcoexist, 1821 NORMAL_EXEC, 2); 1822 } 1823 } 1824 } 1825 1826 static void btc8821a1ant_run_sw_coex_mech(struct btc_coexist *btcoexist) 1827 { 1828 struct rtl_priv *rtlpriv = btcoexist->adapter; 1829 u8 algorithm = 0; 1830 1831 algorithm = btc8821a1ant_action_algorithm(btcoexist); 1832 coex_dm->cur_algorithm = algorithm; 1833 1834 if (!btc8821a1ant_is_common_action(btcoexist)) { 1835 switch (coex_dm->cur_algorithm) { 1836 case BT_8821A_1ANT_COEX_ALGO_SCO: 1837 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1838 "[BTCoex], Action algorithm = SCO\n"); 1839 btc8821a1ant_action_sco(btcoexist); 1840 break; 1841 case BT_8821A_1ANT_COEX_ALGO_HID: 1842 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1843 "[BTCoex], Action algorithm = HID\n"); 1844 btc8821a1ant_action_hid(btcoexist); 1845 break; 1846 case BT_8821A_1ANT_COEX_ALGO_A2DP: 1847 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1848 "[BTCoex], Action algorithm = A2DP\n"); 1849 btc8821a1ant_action_a2dp(btcoexist); 1850 break; 1851 case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS: 1852 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1853 "[BTCoex], Action algorithm = A2DP+PAN(HS)\n"); 1854 btc8821a1ant_action_a2dp_pan_hs(btcoexist); 1855 break; 1856 case BT_8821A_1ANT_COEX_ALGO_PANEDR: 1857 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1858 "[BTCoex], Action algorithm = PAN(EDR)\n"); 1859 btc8821a1ant_action_pan_edr(btcoexist); 1860 break; 1861 case BT_8821A_1ANT_COEX_ALGO_PANHS: 1862 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1863 "[BTCoex], Action algorithm = HS mode\n"); 1864 btc8821a1ant_action_pan_hs(btcoexist); 1865 break; 1866 case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP: 1867 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1868 "[BTCoex], Action algorithm = PAN+A2DP\n"); 1869 btc8821a1ant_action_pan_edr_a2dp(btcoexist); 1870 break; 1871 case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID: 1872 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1873 "[BTCoex], Action algorithm = PAN(EDR)+HID\n"); 1874 btc8821a1ant_action_pan_edr_hid(btcoexist); 1875 break; 1876 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR: 1877 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1878 "[BTCoex], Action algorithm = HID+A2DP+PAN\n"); 1879 btc8821a1ant_action_hid_a2dp_pan_edr(btcoexist); 1880 break; 1881 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP: 1882 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1883 "[BTCoex], Action algorithm = HID+A2DP\n"); 1884 btc8821a1ant_action_hid_a2dp(btcoexist); 1885 break; 1886 default: 1887 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1888 "[BTCoex], Action algorithm = coexist All Off!!\n"); 1889 /*btc8821a1ant_coex_all_off(btcoexist);*/ 1890 break; 1891 } 1892 coex_dm->pre_algorithm = coex_dm->cur_algorithm; 1893 } 1894 } 1895 1896 static void btc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist) 1897 { 1898 struct rtl_priv *rtlpriv = btcoexist->adapter; 1899 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1900 bool wifi_connected = false, bt_hs_on = false; 1901 bool increase_scan_dev_num = false; 1902 bool bt_ctrl_agg_buf_size = false; 1903 u8 agg_buf_size = 5; 1904 u32 wifi_link_status = 0; 1905 u32 num_of_wifi_link = 0; 1906 bool wifi_under_5g = false; 1907 1908 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1909 "[BTCoex], RunCoexistMechanism()===>\n"); 1910 1911 if (btcoexist->manual_control) { 1912 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1913 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n"); 1914 return; 1915 } 1916 1917 if (btcoexist->stop_coex_dm) { 1918 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1919 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n"); 1920 return; 1921 } 1922 1923 if (coex_sta->under_ips) { 1924 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1925 "[BTCoex], wifi is under IPS !!!\n"); 1926 return; 1927 } 1928 1929 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 1930 if (wifi_under_5g) { 1931 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1932 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 1933 btc8821a1ant_coex_under_5g(btcoexist); 1934 return; 1935 } 1936 1937 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) || 1938 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || 1939 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) 1940 increase_scan_dev_num = true; 1941 1942 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM, 1943 &increase_scan_dev_num); 1944 1945 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 1946 &wifi_connected); 1947 1948 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 1949 &wifi_link_status); 1950 num_of_wifi_link = wifi_link_status >> 16; 1951 if ((num_of_wifi_link >= 2) || 1952 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) { 1953 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 1954 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 1955 bt_ctrl_agg_buf_size, agg_buf_size); 1956 btc8821a1ant_action_wifi_multi_port(btcoexist); 1957 return; 1958 } 1959 1960 if (!bt_link_info->sco_exist && !bt_link_info->hid_exist) { 1961 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 1962 } else { 1963 if (wifi_connected) { 1964 btc8821a1ant_wifi_rssi_state(btcoexist, 1, 2, 1965 30, 0); 1966 btc8821a1ant_limited_tx(btcoexist, 1967 NORMAL_EXEC, 1, 1, 1968 0, 1); 1969 } else { 1970 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 1971 0, 0, 0, 0); 1972 } 1973 } 1974 1975 if (bt_link_info->sco_exist) { 1976 bt_ctrl_agg_buf_size = true; 1977 agg_buf_size = 0x3; 1978 } else if (bt_link_info->hid_exist) { 1979 bt_ctrl_agg_buf_size = true; 1980 agg_buf_size = 0x5; 1981 } else if (bt_link_info->a2dp_exist || bt_link_info->pan_exist) { 1982 bt_ctrl_agg_buf_size = true; 1983 agg_buf_size = 0x8; 1984 } 1985 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 1986 bt_ctrl_agg_buf_size, agg_buf_size); 1987 1988 btc8821a1ant_run_sw_coex_mech(btcoexist); 1989 1990 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 1991 if (coex_sta->c2h_bt_inquiry_page) { 1992 btc8821a1ant_action_bt_inquiry(btcoexist); 1993 return; 1994 } else if (bt_hs_on) { 1995 btc8821a1ant_action_hs(btcoexist); 1996 return; 1997 } 1998 1999 if (!wifi_connected) { 2000 bool scan = false, link = false, roam = false; 2001 2002 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2003 "[BTCoex], wifi is non connected-idle !!!\n"); 2004 2005 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2006 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2007 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2008 2009 if (scan || link || roam) { 2010 if (scan) 2011 btc8821a1ant_act_wifi_not_conn_scan(btcoexist); 2012 else 2013 btc8821a1ant_action_wifi_not_connected_asso_auth( 2014 btcoexist); 2015 } else { 2016 btc8821a1ant_action_wifi_not_connected(btcoexist); 2017 } 2018 } else { 2019 /* wifi LPS/Busy */ 2020 btc8821a1ant_action_wifi_connected(btcoexist); 2021 } 2022 } 2023 2024 static void btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist) 2025 { 2026 /* force to reset coex mechanism 2027 * sw all off 2028 */ 2029 btc8821a1ant_sw_mechanism(btcoexist, false); 2030 2031 btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); 2032 } 2033 2034 static void btc8821a1ant_init_hw_config(struct btc_coexist *btcoexist, 2035 bool back_up, bool wifi_only) 2036 { 2037 struct rtl_priv *rtlpriv = btcoexist->adapter; 2038 u8 u1_tmp = 0; 2039 bool wifi_under_5g = false; 2040 2041 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2042 "[BTCoex], 1Ant Init HW Config!!\n"); 2043 2044 if (wifi_only) 2045 return; 2046 2047 if (back_up) { 2048 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist, 2049 0x430); 2050 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist, 2051 0x434); 2052 coex_dm->backup_retry_limit = 2053 btcoexist->btc_read_2byte(btcoexist, 0x42a); 2054 coex_dm->backup_ampdu_max_time = 2055 btcoexist->btc_read_1byte(btcoexist, 0x456); 2056 } 2057 2058 /* 0x790[5:0] = 0x5 */ 2059 u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790); 2060 u1_tmp &= 0xc0; 2061 u1_tmp |= 0x5; 2062 btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp); 2063 2064 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2065 2066 /* Antenna config */ 2067 if (wifi_under_5g) 2068 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, 2069 true, false); 2070 else 2071 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2072 true, false); 2073 /* PTA parameter */ 2074 btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); 2075 2076 /* Enable counter statistics 2077 * 0x76e[3] =1, WLAN_Act control by PTA 2078 */ 2079 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); 2080 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3); 2081 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1); 2082 } 2083 2084 /************************************************************** 2085 * extern function start with ex_btc8821a1ant_ 2086 **************************************************************/ 2087 void ex_btc8821a1ant_init_hwconfig(struct btc_coexist *btcoexist, bool wifionly) 2088 { 2089 btc8821a1ant_init_hw_config(btcoexist, true, wifionly); 2090 btcoexist->auto_report_1ant = true; 2091 } 2092 2093 void ex_btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist) 2094 { 2095 struct rtl_priv *rtlpriv = btcoexist->adapter; 2096 2097 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2098 "[BTCoex], Coex Mechanism Init!!\n"); 2099 2100 btcoexist->stop_coex_dm = false; 2101 2102 btc8821a1ant_init_coex_dm(btcoexist); 2103 2104 btc8821a1ant_query_bt_info(btcoexist); 2105 } 2106 2107 void ex_btc8821a1ant_display_coex_info(struct btc_coexist *btcoexist, 2108 struct seq_file *m) 2109 { 2110 struct btc_board_info *board_info = &btcoexist->board_info; 2111 struct btc_stack_info *stack_info = &btcoexist->stack_info; 2112 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 2113 u8 u1_tmp[4], i, bt_info_ext, ps_tdma_case = 0; 2114 u16 u2_tmp[4]; 2115 u32 u4_tmp[4]; 2116 bool roam = false, scan = false, link = false, wifi_under_5g = false; 2117 bool bt_hs_on = false, wifi_busy = false; 2118 long wifi_rssi = 0, bt_hs_rssi = 0; 2119 u32 wifi_bw, wifi_traffic_dir; 2120 u8 wifi_dot11_chnl, wifi_hs_chnl; 2121 u32 fw_ver = 0, bt_patch_ver = 0; 2122 2123 seq_puts(m, "\n ============[BT Coexist info]============"); 2124 2125 if (btcoexist->manual_control) { 2126 seq_puts(m, "\n ============[Under Manual Control]============"); 2127 seq_puts(m, "\n =========================================="); 2128 } 2129 if (btcoexist->stop_coex_dm) { 2130 seq_puts(m, "\n ============[Coex is STOPPED]============"); 2131 seq_puts(m, "\n =========================================="); 2132 } 2133 2134 seq_printf(m, "\n %-35s = %d/ %d/ %d", 2135 "Ant PG Num/ Ant Mech/ Ant Pos:", 2136 board_info->pg_ant_num, 2137 board_info->btdm_ant_num, 2138 board_info->btdm_ant_pos); 2139 2140 seq_printf(m, "\n %-35s = %s / %d", "BT stack/ hci ext ver", 2141 ((stack_info->profile_notified) ? "Yes" : "No"), 2142 stack_info->hci_version); 2143 2144 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, 2145 &bt_patch_ver); 2146 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 2147 seq_printf(m, "\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", 2148 "CoexVer/ FwVer/ PatchVer", 2149 glcoex_ver_date_8821a_1ant, 2150 glcoex_ver_8821a_1ant, 2151 fw_ver, bt_patch_ver, 2152 bt_patch_ver); 2153 2154 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, 2155 &bt_hs_on); 2156 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL, 2157 &wifi_dot11_chnl); 2158 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, 2159 &wifi_hs_chnl); 2160 seq_printf(m, "\n %-35s = %d / %d(%d)", 2161 "Dot11 channel / HsChnl(HsMode)", 2162 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on); 2163 2164 seq_printf(m, "\n %-35s = %3ph ", 2165 "H2C Wifi inform bt chnl Info", 2166 coex_dm->wifi_chnl_info); 2167 2168 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); 2169 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi); 2170 seq_printf(m, "\n %-35s = %d/ %d", "Wifi rssi/ HS rssi", 2171 (int)wifi_rssi, (int)bt_hs_rssi); 2172 2173 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2174 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2175 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2176 seq_printf(m, "\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan", 2177 link, roam, scan); 2178 2179 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, 2180 &wifi_under_5g); 2181 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, 2182 &wifi_bw); 2183 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, 2184 &wifi_busy); 2185 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, 2186 &wifi_traffic_dir); 2187 seq_printf(m, "\n %-35s = %s / %s/ %s ", "Wifi status", 2188 (wifi_under_5g ? "5G" : "2.4G"), 2189 ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" : 2190 (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))), 2191 ((!wifi_busy) ? "idle" : 2192 ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ? 2193 "uplink" : "downlink"))); 2194 seq_printf(m, "\n %-35s = [%s/ %d/ %d] ", 2195 "BT [status/ rssi/ retryCnt]", 2196 ((coex_sta->bt_disabled) ? ("disabled") : 2197 ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") : 2198 ((BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == 2199 coex_dm->bt_status) ? 2200 "non-connected idle" : 2201 ((BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE == 2202 coex_dm->bt_status) ? 2203 "connected-idle" : "busy")))), 2204 coex_sta->bt_rssi, coex_sta->bt_retry_cnt); 2205 2206 seq_printf(m, "\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", 2207 bt_link_info->sco_exist, 2208 bt_link_info->hid_exist, 2209 bt_link_info->pan_exist, 2210 bt_link_info->a2dp_exist); 2211 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO, m); 2212 2213 bt_info_ext = coex_sta->bt_info_ext; 2214 seq_printf(m, "\n %-35s = %s", 2215 "BT Info A2DP rate", 2216 (bt_info_ext & BIT0) ? 2217 "Basic rate" : "EDR rate"); 2218 2219 for (i = 0; i < BT_INFO_SRC_8821A_1ANT_MAX; i++) { 2220 if (coex_sta->bt_info_c2h_cnt[i]) { 2221 seq_printf(m, "\n %-35s = %7ph(%d)", 2222 glbt_info_src_8821a_1ant[i], 2223 coex_sta->bt_info_c2h[i], 2224 coex_sta->bt_info_c2h_cnt[i]); 2225 } 2226 } 2227 seq_printf(m, "\n %-35s = %s/%s, (0x%x/0x%x)", 2228 "PS state, IPS/LPS, (lps/rpwm)", 2229 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")), 2230 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")), 2231 btcoexist->bt_info.lps_val, 2232 btcoexist->bt_info.rpwm_val); 2233 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD, m); 2234 2235 if (!btcoexist->manual_control) { 2236 /* Sw mechanism*/ 2237 seq_printf(m, "\n %-35s", 2238 "============[Sw mechanism]============"); 2239 2240 seq_printf(m, "\n %-35s = %d", "SM[LowPenaltyRA]", 2241 coex_dm->cur_low_penalty_ra); 2242 2243 seq_printf(m, "\n %-35s = %s/ %s/ %d ", 2244 "DelBA/ BtCtrlAgg/ AggSize", 2245 (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"), 2246 (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"), 2247 btcoexist->bt_info.agg_buf_size); 2248 seq_printf(m, "\n %-35s = 0x%x ", "Rate Mask", 2249 btcoexist->bt_info.ra_mask); 2250 2251 /* Fw mechanism */ 2252 seq_printf(m, "\n %-35s", 2253 "============[Fw mechanism]============"); 2254 2255 ps_tdma_case = coex_dm->cur_ps_tdma; 2256 seq_printf(m, "\n %-35s = %5ph case-%d (auto:%d)", 2257 "PS TDMA", 2258 coex_dm->ps_tdma_para, 2259 ps_tdma_case, 2260 coex_dm->auto_tdma_adjust); 2261 2262 seq_printf(m, "\n %-35s = 0x%x ", 2263 "Latest error condition(should be 0)", 2264 coex_dm->error_condition); 2265 2266 seq_printf(m, "\n %-35s = %d ", "IgnWlanAct", 2267 coex_dm->cur_ignore_wlan_act); 2268 } 2269 2270 /* Hw setting */ 2271 seq_printf(m, "\n %-35s", "============[Hw setting]============"); 2272 2273 seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x", 2274 "backup ARFR1/ARFR2/RL/AMaxTime", 2275 coex_dm->backup_arfr_cnt1, 2276 coex_dm->backup_arfr_cnt2, 2277 coex_dm->backup_retry_limit, 2278 coex_dm->backup_ampdu_max_time); 2279 2280 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430); 2281 u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434); 2282 u2_tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a); 2283 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456); 2284 seq_printf(m, "\n %-35s = 0x%x/0x%x/0x%x/0x%x", 2285 "0x430/0x434/0x42a/0x456", 2286 u4_tmp[0], u4_tmp[1], u2_tmp[0], u1_tmp[0]); 2287 2288 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778); 2289 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc58); 2290 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x778/ 0xc58[29:25]", 2291 u1_tmp[0], (u4_tmp[0] & 0x3e000000) >> 25); 2292 2293 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db); 2294 seq_printf(m, "\n %-35s = 0x%x", "0x8db[6:5]", 2295 ((u1_tmp[0] & 0x60) >> 5)); 2296 2297 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x975); 2298 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4); 2299 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x", 2300 "0xcb4[29:28]/0xcb4[7:0]/0x974[9:8]", 2301 (u4_tmp[0] & 0x30000000) >> 28, 2302 u4_tmp[0] & 0xff, 2303 u1_tmp[0] & 0x3); 2304 2305 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40); 2306 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c); 2307 u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x64); 2308 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x", 2309 "0x40/0x4c[24:23]/0x64[0]", 2310 u1_tmp[0], ((u4_tmp[0] & 0x01800000) >> 23), 2311 u1_tmp[1] & 0x1); 2312 2313 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550); 2314 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522); 2315 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522", 2316 u4_tmp[0], u1_tmp[0]); 2317 2318 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50); 2319 seq_printf(m, "\n %-35s = 0x%x", "0xc50(dig)", 2320 u4_tmp[0] & 0xff); 2321 2322 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48); 2323 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5d); 2324 u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c); 2325 seq_printf(m, "\n %-35s = 0x%x/ 0x%x", "OFDM-FA/ CCK-FA", 2326 u4_tmp[0], (u1_tmp[0] << 8) + u1_tmp[1]); 2327 2328 u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0); 2329 u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4); 2330 u4_tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8); 2331 u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc); 2332 seq_printf(m, "\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", 2333 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", 2334 u4_tmp[0], u4_tmp[1], u4_tmp[2], u1_tmp[0]); 2335 2336 seq_printf(m, "\n %-35s = %d/ %d", "0x770(high-pri rx/tx)", 2337 coex_sta->high_priority_rx, coex_sta->high_priority_tx); 2338 seq_printf(m, "\n %-35s = %d/ %d", "0x774(low-pri rx/tx)", 2339 coex_sta->low_priority_rx, coex_sta->low_priority_tx); 2340 if (btcoexist->auto_report_1ant) 2341 btc8821a1ant_monitor_bt_ctr(btcoexist); 2342 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS, m); 2343 } 2344 2345 void ex_btc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type) 2346 { 2347 struct rtl_priv *rtlpriv = btcoexist->adapter; 2348 bool wifi_under_5g = false; 2349 2350 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2351 return; 2352 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2353 if (wifi_under_5g) { 2354 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2355 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2356 btc8821a1ant_coex_under_5g(btcoexist); 2357 return; 2358 } 2359 2360 if (BTC_IPS_ENTER == type) { 2361 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2362 "[BTCoex], IPS ENTER notify\n"); 2363 coex_sta->under_ips = true; 2364 btc8821a1ant_set_ant_path(btcoexist, 2365 BTC_ANT_PATH_BT, false, true); 2366 /* set PTA control */ 2367 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0); 2368 btc8821a1ant_coex_table_with_type(btcoexist, 2369 NORMAL_EXEC, 0); 2370 } else if (BTC_IPS_LEAVE == type) { 2371 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2372 "[BTCoex], IPS LEAVE notify\n"); 2373 coex_sta->under_ips = false; 2374 2375 btc8821a1ant_init_hw_config(btcoexist, false, false); 2376 btc8821a1ant_init_coex_dm(btcoexist); 2377 btc8821a1ant_query_bt_info(btcoexist); 2378 } 2379 } 2380 2381 void ex_btc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type) 2382 { 2383 struct rtl_priv *rtlpriv = btcoexist->adapter; 2384 2385 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2386 return; 2387 2388 if (BTC_LPS_ENABLE == type) { 2389 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2390 "[BTCoex], LPS ENABLE notify\n"); 2391 coex_sta->under_lps = true; 2392 } else if (BTC_LPS_DISABLE == type) { 2393 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2394 "[BTCoex], LPS DISABLE notify\n"); 2395 coex_sta->under_lps = false; 2396 } 2397 } 2398 2399 void ex_btc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type) 2400 { 2401 struct rtl_priv *rtlpriv = btcoexist->adapter; 2402 bool wifi_connected = false, bt_hs_on = false; 2403 bool bt_ctrl_agg_buf_size = false; 2404 bool wifi_under_5g = false; 2405 u32 wifi_link_status = 0; 2406 u32 num_of_wifi_link = 0; 2407 u8 agg_buf_size = 5; 2408 2409 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2410 return; 2411 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2412 if (wifi_under_5g) { 2413 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2414 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2415 btc8821a1ant_coex_under_5g(btcoexist); 2416 return; 2417 } 2418 2419 if (type == BTC_SCAN_START) { 2420 coex_sta->wifi_is_high_pri_task = true; 2421 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2422 "[BTCoex], SCAN START notify\n"); 2423 2424 /* Force antenna setup for no scan result issue */ 2425 btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 2426 } else { 2427 coex_sta->wifi_is_high_pri_task = false; 2428 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2429 "[BTCoex], SCAN FINISH notify\n"); 2430 } 2431 2432 if (coex_sta->bt_disabled) 2433 return; 2434 2435 btcoexist->btc_get(btcoexist, 2436 BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2437 btcoexist->btc_get(btcoexist, 2438 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); 2439 2440 btc8821a1ant_query_bt_info(btcoexist); 2441 2442 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2443 &wifi_link_status); 2444 num_of_wifi_link = wifi_link_status >> 16; 2445 if (num_of_wifi_link >= 2) { 2446 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2447 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2448 bt_ctrl_agg_buf_size, agg_buf_size); 2449 btc8821a1ant_action_wifi_multi_port(btcoexist); 2450 return; 2451 } 2452 2453 if (coex_sta->c2h_bt_inquiry_page) { 2454 btc8821a1ant_action_bt_inquiry(btcoexist); 2455 return; 2456 } else if (bt_hs_on) { 2457 btc8821a1ant_action_hs(btcoexist); 2458 return; 2459 } 2460 2461 if (BTC_SCAN_START == type) { 2462 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2463 "[BTCoex], SCAN START notify\n"); 2464 if (!wifi_connected) { 2465 /* non-connected scan */ 2466 btc8821a1ant_act_wifi_not_conn_scan(btcoexist); 2467 } else { 2468 /* wifi is connected */ 2469 btc8821a1ant_action_wifi_connected_scan(btcoexist); 2470 } 2471 } else if (BTC_SCAN_FINISH == type) { 2472 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2473 "[BTCoex], SCAN FINISH notify\n"); 2474 if (!wifi_connected) { 2475 /* non-connected scan */ 2476 btc8821a1ant_action_wifi_not_connected(btcoexist); 2477 } else { 2478 btc8821a1ant_action_wifi_connected(btcoexist); 2479 } 2480 } 2481 } 2482 2483 void ex_btc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type) 2484 { 2485 struct rtl_priv *rtlpriv = btcoexist->adapter; 2486 bool wifi_connected = false, bt_hs_on = false; 2487 u32 wifi_link_status = 0; 2488 u32 num_of_wifi_link = 0; 2489 bool bt_ctrl_agg_buf_size = false; 2490 bool wifi_under_5g = false; 2491 u8 agg_buf_size = 5; 2492 2493 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 2494 coex_sta->bt_disabled) 2495 return; 2496 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2497 if (wifi_under_5g) { 2498 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2499 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2500 btc8821a1ant_coex_under_5g(btcoexist); 2501 return; 2502 } 2503 2504 if (type == BTC_ASSOCIATE_START) { 2505 coex_sta->wifi_is_high_pri_task = true; 2506 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2507 "[BTCoex], CONNECT START notify\n"); 2508 coex_dm->arp_cnt = 0; 2509 } else { 2510 coex_sta->wifi_is_high_pri_task = false; 2511 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2512 "[BTCoex], CONNECT FINISH notify\n"); 2513 coex_dm->arp_cnt = 0; 2514 } 2515 2516 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2517 &wifi_link_status); 2518 num_of_wifi_link = wifi_link_status >> 16; 2519 if (num_of_wifi_link >= 2) { 2520 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2521 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2522 bt_ctrl_agg_buf_size, agg_buf_size); 2523 btc8821a1ant_action_wifi_multi_port(btcoexist); 2524 return; 2525 } 2526 2527 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2528 if (coex_sta->c2h_bt_inquiry_page) { 2529 btc8821a1ant_action_bt_inquiry(btcoexist); 2530 return; 2531 } else if (bt_hs_on) { 2532 btc8821a1ant_action_hs(btcoexist); 2533 return; 2534 } 2535 2536 if (BTC_ASSOCIATE_START == type) { 2537 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2538 "[BTCoex], CONNECT START notify\n"); 2539 btc8821a1ant_act_wifi_not_conn_scan(btcoexist); 2540 } else if (BTC_ASSOCIATE_FINISH == type) { 2541 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2542 "[BTCoex], CONNECT FINISH notify\n"); 2543 2544 btcoexist->btc_get(btcoexist, 2545 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); 2546 if (!wifi_connected) { 2547 /* non-connected scan */ 2548 btc8821a1ant_action_wifi_not_connected(btcoexist); 2549 } else { 2550 btc8821a1ant_action_wifi_connected(btcoexist); 2551 } 2552 } 2553 } 2554 2555 void ex_btc8821a1ant_media_status_notify(struct btc_coexist *btcoexist, 2556 u8 type) 2557 { 2558 struct rtl_priv *rtlpriv = btcoexist->adapter; 2559 u8 h2c_parameter[3] = {0}; 2560 u32 wifi_bw; 2561 u8 wifi_central_chnl; 2562 bool wifi_under_5g = false; 2563 2564 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 2565 coex_sta->bt_disabled) 2566 return; 2567 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2568 if (wifi_under_5g) { 2569 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2570 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2571 btc8821a1ant_coex_under_5g(btcoexist); 2572 return; 2573 } 2574 2575 if (BTC_MEDIA_CONNECT == type) { 2576 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2577 "[BTCoex], MEDIA connect notify\n"); 2578 } else { 2579 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2580 "[BTCoex], MEDIA disconnect notify\n"); 2581 coex_dm->arp_cnt = 0; 2582 } 2583 2584 /* only 2.4G we need to inform bt the chnl mask */ 2585 btcoexist->btc_get(btcoexist, 2586 BTC_GET_U1_WIFI_CENTRAL_CHNL, 2587 &wifi_central_chnl); 2588 if ((type == BTC_MEDIA_CONNECT) && 2589 (wifi_central_chnl <= 14)) { 2590 h2c_parameter[0] = 0x0; 2591 h2c_parameter[1] = wifi_central_chnl; 2592 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2593 if (wifi_bw == BTC_WIFI_BW_HT40) 2594 h2c_parameter[2] = 0x30; 2595 else 2596 h2c_parameter[2] = 0x20; 2597 } 2598 2599 coex_dm->wifi_chnl_info[0] = h2c_parameter[0]; 2600 coex_dm->wifi_chnl_info[1] = h2c_parameter[1]; 2601 coex_dm->wifi_chnl_info[2] = h2c_parameter[2]; 2602 2603 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2604 "[BTCoex], FW write 0x66 = 0x%x\n", 2605 h2c_parameter[0] << 16 | 2606 h2c_parameter[1] << 8 | 2607 h2c_parameter[2]); 2608 2609 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter); 2610 } 2611 2612 void ex_btc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist, 2613 u8 type) 2614 { 2615 struct rtl_priv *rtlpriv = btcoexist->adapter; 2616 bool bt_hs_on = false; 2617 bool bt_ctrl_agg_buf_size = false; 2618 bool wifi_under_5g = false; 2619 u32 wifi_link_status = 0; 2620 u32 num_of_wifi_link = 0; 2621 u8 agg_buf_size = 5; 2622 2623 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 2624 coex_sta->bt_disabled) 2625 return; 2626 2627 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2628 if (wifi_under_5g) { 2629 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2630 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2631 btc8821a1ant_coex_under_5g(btcoexist); 2632 return; 2633 } 2634 2635 if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL || 2636 type == BTC_PACKET_ARP) { 2637 coex_sta->wifi_is_high_pri_task = true; 2638 2639 if (type == BTC_PACKET_ARP) { 2640 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2641 "[BTCoex], specific Packet ARP notify\n"); 2642 } else { 2643 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2644 "[BTCoex], specific Packet DHCP or EAPOL notify\n"); 2645 } 2646 } else { 2647 coex_sta->wifi_is_high_pri_task = false; 2648 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2649 "[BTCoex], specific Packet [Type = %d] notify\n", 2650 type); 2651 } 2652 2653 coex_sta->special_pkt_period_cnt = 0; 2654 2655 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2656 &wifi_link_status); 2657 num_of_wifi_link = wifi_link_status >> 16; 2658 if (num_of_wifi_link >= 2) { 2659 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2660 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2661 bt_ctrl_agg_buf_size, agg_buf_size); 2662 btc8821a1ant_action_wifi_multi_port(btcoexist); 2663 return; 2664 } 2665 2666 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2667 if (coex_sta->c2h_bt_inquiry_page) { 2668 btc8821a1ant_action_bt_inquiry(btcoexist); 2669 return; 2670 } else if (bt_hs_on) { 2671 btc8821a1ant_action_hs(btcoexist); 2672 return; 2673 } 2674 2675 if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL || 2676 type == BTC_PACKET_ARP) { 2677 if (type == BTC_PACKET_ARP) { 2678 coex_dm->arp_cnt++; 2679 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2680 "[BTCoex], ARP Packet Count = %d\n", 2681 coex_dm->arp_cnt); 2682 if (coex_dm->arp_cnt >= 10) 2683 /* if APR PKT > 10 after connect, do not go to 2684 * btc8821a1ant_act_wifi_conn_sp_pkt 2685 */ 2686 return; 2687 } 2688 2689 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2690 "[BTCoex], special Packet(%d) notify\n", type); 2691 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist); 2692 } 2693 } 2694 2695 void ex_btc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist, 2696 u8 *tmp_buf, u8 length) 2697 { 2698 struct rtl_priv *rtlpriv = btcoexist->adapter; 2699 u8 i; 2700 u8 bt_info = 0; 2701 u8 rsp_source = 0; 2702 bool wifi_connected = false; 2703 bool bt_busy = false; 2704 bool wifi_under_5g = false; 2705 2706 coex_sta->c2h_bt_info_req_sent = false; 2707 2708 btcoexist->btc_get(btcoexist, 2709 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2710 2711 rsp_source = tmp_buf[0] & 0xf; 2712 if (rsp_source >= BT_INFO_SRC_8821A_1ANT_MAX) 2713 rsp_source = BT_INFO_SRC_8821A_1ANT_WIFI_FW; 2714 coex_sta->bt_info_c2h_cnt[rsp_source]++; 2715 2716 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2717 "[BTCoex], Bt info[%d], length = %d, hex data = [", 2718 rsp_source, length); 2719 for (i = 0; i < length; i++) { 2720 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i]; 2721 if (i == 1) 2722 bt_info = tmp_buf[i]; 2723 if (i == length - 1) { 2724 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2725 "0x%02x]\n", tmp_buf[i]); 2726 } else { 2727 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2728 "0x%02x, ", tmp_buf[i]); 2729 } 2730 } 2731 2732 if (BT_INFO_SRC_8821A_1ANT_WIFI_FW != rsp_source) { 2733 /* [3:0] */ 2734 coex_sta->bt_retry_cnt = 2735 coex_sta->bt_info_c2h[rsp_source][2] & 0xf; 2736 2737 coex_sta->bt_rssi = 2738 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10; 2739 2740 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4]; 2741 2742 coex_sta->bt_tx_rx_mask = 2743 (coex_sta->bt_info_c2h[rsp_source][2] & 0x40); 2744 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK, 2745 &coex_sta->bt_tx_rx_mask); 2746 if (!coex_sta->bt_tx_rx_mask) { 2747 /* BT into is responded by BT FW and BT RF REG 0x3C != 2748 * 0x15 => Need to switch BT TRx Mask 2749 */ 2750 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2751 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n"); 2752 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 2753 0x3c, 0x15); 2754 } 2755 2756 /* Here we need to resend some wifi info to BT 2757 * because bt is reset and lost the info 2758 */ 2759 if (coex_sta->bt_info_ext & BIT1) { 2760 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2761 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n"); 2762 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 2763 &wifi_connected); 2764 if (wifi_connected) { 2765 ex_btc8821a1ant_media_status_notify(btcoexist, 2766 BTC_MEDIA_CONNECT); 2767 } else { 2768 ex_btc8821a1ant_media_status_notify(btcoexist, 2769 BTC_MEDIA_DISCONNECT); 2770 } 2771 } 2772 2773 if ((coex_sta->bt_info_ext & BIT3) && !wifi_under_5g) { 2774 if (!btcoexist->manual_control && 2775 !btcoexist->stop_coex_dm) { 2776 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2777 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n"); 2778 btc8821a1ant_ignore_wlan_act(btcoexist, 2779 FORCE_EXEC, 2780 false); 2781 } 2782 } 2783 } 2784 2785 /* check BIT2 first ==> check if bt is under inquiry or page scan */ 2786 if (bt_info & BT_INFO_8821A_1ANT_B_INQ_PAGE) 2787 coex_sta->c2h_bt_inquiry_page = true; 2788 else 2789 coex_sta->c2h_bt_inquiry_page = false; 2790 2791 /* set link exist status */ 2792 if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) { 2793 coex_sta->bt_link_exist = false; 2794 coex_sta->pan_exist = false; 2795 coex_sta->a2dp_exist = false; 2796 coex_sta->hid_exist = false; 2797 coex_sta->sco_exist = false; 2798 } else { 2799 /* connection exists */ 2800 coex_sta->bt_link_exist = true; 2801 if (bt_info & BT_INFO_8821A_1ANT_B_FTP) 2802 coex_sta->pan_exist = true; 2803 else 2804 coex_sta->pan_exist = false; 2805 if (bt_info & BT_INFO_8821A_1ANT_B_A2DP) 2806 coex_sta->a2dp_exist = true; 2807 else 2808 coex_sta->a2dp_exist = false; 2809 if (bt_info & BT_INFO_8821A_1ANT_B_HID) 2810 coex_sta->hid_exist = true; 2811 else 2812 coex_sta->hid_exist = false; 2813 if (bt_info & BT_INFO_8821A_1ANT_B_SCO_ESCO) 2814 coex_sta->sco_exist = true; 2815 else 2816 coex_sta->sco_exist = false; 2817 } 2818 2819 btc8821a1ant_update_bt_link_info(btcoexist); 2820 2821 /* mask profile bit for connect-ilde identification 2822 * (for CSR case: A2DP idle --> 0x41) 2823 */ 2824 bt_info = bt_info & 0x1f; 2825 2826 if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) { 2827 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE; 2828 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2829 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n"); 2830 } else if (bt_info == BT_INFO_8821A_1ANT_B_CONNECTION) { 2831 /* connection exists but no busy */ 2832 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE; 2833 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2834 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n"); 2835 } else if ((bt_info&BT_INFO_8821A_1ANT_B_SCO_ESCO) || 2836 (bt_info & BT_INFO_8821A_1ANT_B_SCO_BUSY)) { 2837 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_SCO_BUSY; 2838 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2839 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n"); 2840 } else if (bt_info & BT_INFO_8821A_1ANT_B_ACL_BUSY) { 2841 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status) 2842 coex_dm->auto_tdma_adjust = false; 2843 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_ACL_BUSY; 2844 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2845 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n"); 2846 } else { 2847 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_MAX; 2848 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2849 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n"); 2850 } 2851 2852 if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) || 2853 (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || 2854 (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) 2855 bt_busy = true; 2856 else 2857 bt_busy = false; 2858 btcoexist->btc_set(btcoexist, 2859 BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy); 2860 2861 btc8821a1ant_run_coexist_mechanism(btcoexist); 2862 } 2863 2864 void ex_btc8821a1ant_halt_notify(struct btc_coexist *btcoexist) 2865 { 2866 struct rtl_priv *rtlpriv = btcoexist->adapter; 2867 bool wifi_under_5g = false; 2868 2869 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2870 "[BTCoex], Halt notify\n"); 2871 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2872 if (wifi_under_5g) { 2873 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2874 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2875 btc8821a1ant_coex_under_5g(btcoexist); 2876 return; 2877 } 2878 2879 2880 btcoexist->stop_coex_dm = true; 2881 2882 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, true); 2883 btc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true); 2884 2885 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0); 2886 btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0); 2887 2888 ex_btc8821a1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT); 2889 } 2890 2891 void ex_btc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state) 2892 { 2893 struct rtl_priv *rtlpriv = btcoexist->adapter; 2894 bool wifi_under_5g = false; 2895 2896 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 2897 if (wifi_under_5g) { 2898 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2899 "[BTCoex], RunCoexistMechanism(), return for 5G <===\n"); 2900 btc8821a1ant_coex_under_5g(btcoexist); 2901 return; 2902 } 2903 2904 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2905 "[BTCoex], Pnp notify\n"); 2906 2907 if (BTC_WIFI_PNP_SLEEP == pnp_state) { 2908 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2909 "[BTCoex], Pnp notify to SLEEP\n"); 2910 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch 2911 * state after wakeup. 2912 */ 2913 coex_sta->under_ips = false; 2914 coex_sta->under_lps = false; 2915 btcoexist->stop_coex_dm = true; 2916 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 2917 0x0, 0x0); 2918 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0); 2919 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 2920 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, 2921 true); 2922 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) { 2923 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2924 "[BTCoex], Pnp notify to WAKE UP\n"); 2925 btcoexist->stop_coex_dm = false; 2926 btc8821a1ant_init_hw_config(btcoexist, false, false); 2927 btc8821a1ant_init_coex_dm(btcoexist); 2928 btc8821a1ant_query_bt_info(btcoexist); 2929 } 2930 } 2931 2932 void ex_btc8821a1ant_periodical(struct btc_coexist *btcoexist) 2933 { 2934 struct rtl_priv *rtlpriv = btcoexist->adapter; 2935 static u8 dis_ver_info_cnt; 2936 u32 fw_ver = 0, bt_patch_ver = 0; 2937 struct btc_board_info *board_info = &btcoexist->board_info; 2938 struct btc_stack_info *stack_info = &btcoexist->stack_info; 2939 2940 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2941 "[BTCoex], ==========================Periodical===========================\n"); 2942 2943 if (dis_ver_info_cnt <= 5) { 2944 dis_ver_info_cnt += 1; 2945 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2946 "[BTCoex], ****************************************************************\n"); 2947 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2948 "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n", 2949 board_info->pg_ant_num, 2950 board_info->btdm_ant_num, 2951 board_info->btdm_ant_pos); 2952 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2953 "[BTCoex], BT stack/ hci ext ver = %s / %d\n", 2954 stack_info->profile_notified ? "Yes" : "No", 2955 stack_info->hci_version); 2956 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, 2957 &bt_patch_ver); 2958 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 2959 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2960 "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n", 2961 glcoex_ver_date_8821a_1ant, 2962 glcoex_ver_8821a_1ant, 2963 fw_ver, bt_patch_ver, 2964 bt_patch_ver); 2965 rtl_dbg(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2966 "[BTCoex], ****************************************************************\n"); 2967 } 2968 2969 if (!btcoexist->auto_report_1ant) { 2970 btc8821a1ant_query_bt_info(btcoexist); 2971 btc8821a1ant_monitor_bt_ctr(btcoexist); 2972 } else { 2973 coex_sta->special_pkt_period_cnt++; 2974 } 2975 } 2976