1 /****************************************************************************** 2 * 3 * Copyright(c) 2012 Realtek Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * The full GNU General Public License is included in this distribution in the 15 * file called LICENSE. 16 * 17 * Contact Information: 18 * wlanfae <wlanfae@realtek.com> 19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, 20 * Hsinchu 300, Taiwan. 21 * 22 * Larry Finger <Larry.Finger@lwfinger.net> 23 * 24 *****************************************************************************/ 25 26 /*************************************************************** 27 * Description: 28 * 29 * This file is for RTL8723B Co-exist mechanism 30 * 31 * History 32 * 2012/11/15 Cosa first check in. 33 * 34 ***************************************************************/ 35 36 /*************************************************************** 37 * include files 38 ***************************************************************/ 39 #include "halbt_precomp.h" 40 /*************************************************************** 41 * Global variables, these are static variables 42 ***************************************************************/ 43 static struct coex_dm_8723b_1ant glcoex_dm_8723b_1ant; 44 static struct coex_dm_8723b_1ant *coex_dm = &glcoex_dm_8723b_1ant; 45 static struct coex_sta_8723b_1ant glcoex_sta_8723b_1ant; 46 static struct coex_sta_8723b_1ant *coex_sta = &glcoex_sta_8723b_1ant; 47 48 static const char *const glbt_info_src_8723b_1ant[] = { 49 "BT Info[wifi fw]", 50 "BT Info[bt rsp]", 51 "BT Info[bt auto report]", 52 }; 53 54 static u32 glcoex_ver_date_8723b_1ant = 20130918; 55 static u32 glcoex_ver_8723b_1ant = 0x47; 56 57 /*************************************************************** 58 * local function proto type if needed 59 ***************************************************************/ 60 /*************************************************************** 61 * local function start with halbtc8723b1ant_ 62 ***************************************************************/ 63 64 static void halbtc8723b1ant_updatera_mask(struct btc_coexist *btcoexist, 65 bool force_exec, u32 dis_rate_mask) 66 { 67 coex_dm->curra_mask = dis_rate_mask; 68 69 if (force_exec || (coex_dm->prera_mask != coex_dm->curra_mask)) 70 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK, 71 &coex_dm->curra_mask); 72 73 coex_dm->prera_mask = coex_dm->curra_mask; 74 } 75 76 static void btc8723b1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist, 77 bool force_exec, u8 type) 78 { 79 bool wifi_under_bmode = false; 80 81 coex_dm->cur_arfr_type = type; 82 83 if (force_exec || (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) { 84 switch (coex_dm->cur_arfr_type) { 85 case 0: /* normal mode */ 86 btcoexist->btc_write_4byte(btcoexist, 0x430, 87 coex_dm->backup_arfr_cnt1); 88 btcoexist->btc_write_4byte(btcoexist, 0x434, 89 coex_dm->backup_arfr_cnt2); 90 break; 91 case 1: 92 btcoexist->btc_get(btcoexist, 93 BTC_GET_BL_WIFI_UNDER_B_MODE, 94 &wifi_under_bmode); 95 if (wifi_under_bmode) { 96 btcoexist->btc_write_4byte(btcoexist, 97 0x430, 0x0); 98 btcoexist->btc_write_4byte(btcoexist, 99 0x434, 0x01010101); 100 } else { 101 btcoexist->btc_write_4byte(btcoexist, 102 0x430, 0x0); 103 btcoexist->btc_write_4byte(btcoexist, 104 0x434, 0x04030201); 105 } 106 break; 107 default: 108 break; 109 } 110 } 111 112 coex_dm->pre_arfr_type = coex_dm->cur_arfr_type; 113 } 114 115 static void halbtc8723b1ant_retry_limit(struct btc_coexist *btcoexist, 116 bool force_exec, u8 type) 117 { 118 coex_dm->cur_retry_limit_type = type; 119 120 if (force_exec || (coex_dm->pre_retry_limit_type != 121 coex_dm->cur_retry_limit_type)) { 122 switch (coex_dm->cur_retry_limit_type) { 123 case 0: /* normal mode */ 124 btcoexist->btc_write_2byte(btcoexist, 0x42a, 125 coex_dm->backup_retry_limit); 126 break; 127 case 1: /* retry limit = 8 */ 128 btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808); 129 break; 130 default: 131 break; 132 } 133 } 134 135 coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type; 136 } 137 138 static void halbtc8723b1ant_ampdu_maxtime(struct btc_coexist *btcoexist, 139 bool force_exec, u8 type) 140 { 141 coex_dm->cur_ampdu_time_type = type; 142 143 if (force_exec || (coex_dm->pre_ampdu_time_type != 144 coex_dm->cur_ampdu_time_type)) { 145 switch (coex_dm->cur_ampdu_time_type) { 146 case 0: /* normal mode */ 147 btcoexist->btc_write_1byte(btcoexist, 0x456, 148 coex_dm->backup_ampdu_max_time); 149 break; 150 case 1: /* AMPDU timw = 0x38 * 32us */ 151 btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38); 152 break; 153 default: 154 break; 155 } 156 } 157 158 coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type; 159 } 160 161 static void halbtc8723b1ant_limited_tx(struct btc_coexist *btcoexist, 162 bool force_exec, u8 ra_masktype, 163 u8 arfr_type, u8 retry_limit_type, 164 u8 ampdu_time_type) 165 { 166 switch (ra_masktype) { 167 case 0: /* normal mode */ 168 halbtc8723b1ant_updatera_mask(btcoexist, force_exec, 0x0); 169 break; 170 case 1: /* disable cck 1/2 */ 171 halbtc8723b1ant_updatera_mask(btcoexist, force_exec, 172 0x00000003); 173 break; 174 /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */ 175 case 2: 176 halbtc8723b1ant_updatera_mask(btcoexist, force_exec, 177 0x0001f1f7); 178 break; 179 default: 180 break; 181 } 182 183 btc8723b1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type); 184 halbtc8723b1ant_retry_limit(btcoexist, force_exec, retry_limit_type); 185 halbtc8723b1ant_ampdu_maxtime(btcoexist, force_exec, ampdu_time_type); 186 } 187 188 static void halbtc8723b1ant_limited_rx(struct btc_coexist *btcoexist, 189 bool force_exec, bool rej_ap_agg_pkt, 190 bool bt_ctrl_agg_buf_size, 191 u8 agg_buf_size) 192 { 193 bool reject_rx_agg = rej_ap_agg_pkt; 194 bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size; 195 u8 rxaggsize = agg_buf_size; 196 197 /********************************************** 198 * Rx Aggregation related setting 199 **********************************************/ 200 btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, 201 &reject_rx_agg); 202 /* decide BT control aggregation buf size or not */ 203 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, 204 &bt_ctrl_rx_agg_size); 205 /* aggregation buf size, only work 206 * when BT control Rx aggregation size. 207 */ 208 btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxaggsize); 209 /* real update aggregation setting */ 210 btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL); 211 } 212 213 static void halbtc8723b1ant_query_bt_info(struct btc_coexist *btcoexist) 214 { 215 u8 h2c_parameter[1] = {0}; 216 217 coex_sta->c2h_bt_info_req_sent = true; 218 219 /* trigger */ 220 h2c_parameter[0] |= BIT(0); 221 222 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter); 223 } 224 225 static void halbtc8723b1ant_monitor_bt_ctr(struct btc_coexist *btcoexist) 226 { 227 u32 reg_hp_txrx, reg_lp_txrx, u32tmp; 228 u32 reg_hp_tx = 0, reg_hp_rx = 0; 229 u32 reg_lp_tx = 0, reg_lp_rx = 0; 230 static u32 num_of_bt_counter_chk; 231 232 reg_hp_txrx = 0x770; 233 reg_lp_txrx = 0x774; 234 235 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx); 236 reg_hp_tx = u32tmp & MASKLWORD; 237 reg_hp_rx = (u32tmp & MASKHWORD) >> 16; 238 239 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx); 240 reg_lp_tx = u32tmp & MASKLWORD; 241 reg_lp_rx = (u32tmp & MASKHWORD) >> 16; 242 243 coex_sta->high_priority_tx = reg_hp_tx; 244 coex_sta->high_priority_rx = reg_hp_rx; 245 coex_sta->low_priority_tx = reg_lp_tx; 246 coex_sta->low_priority_rx = reg_lp_rx; 247 248 if ((coex_sta->low_priority_tx > 1050) && 249 (!coex_sta->c2h_bt_inquiry_page)) 250 coex_sta->pop_event_cnt++; 251 252 /* reset counter */ 253 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); 254 255 /* This part is for wifi FW and driver to update BT's status as 256 * disabled. 257 * 258 * The flow is as the following 259 * 1. disable BT 260 * 2. if all BT Tx/Rx counter = 0, after 6 sec we query bt info 261 * 3. Because BT will not rsp from mailbox, so wifi fw will know BT is 262 * disabled 263 * 264 * 4. FW will rsp c2h for BT that driver will know BT is disabled. 265 */ 266 if ((reg_hp_tx == 0) && (reg_hp_rx == 0) && (reg_lp_tx == 0) && 267 (reg_lp_rx == 0)) { 268 num_of_bt_counter_chk++; 269 if (num_of_bt_counter_chk == 3) 270 halbtc8723b1ant_query_bt_info(btcoexist); 271 } else { 272 num_of_bt_counter_chk = 0; 273 } 274 } 275 276 static void halbtc8723b1ant_monitor_wifi_ctr(struct btc_coexist *btcoexist) 277 { 278 s32 wifi_rssi = 0; 279 bool wifi_busy = false, wifi_under_b_mode = false; 280 static u8 cck_lock_counter; 281 u32 total_cnt; 282 283 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 284 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); 285 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, 286 &wifi_under_b_mode); 287 288 if (coex_sta->under_ips) { 289 coex_sta->crc_ok_cck = 0; 290 coex_sta->crc_ok_11g = 0; 291 coex_sta->crc_ok_11n = 0; 292 coex_sta->crc_ok_11n_agg = 0; 293 294 coex_sta->crc_err_cck = 0; 295 coex_sta->crc_err_11g = 0; 296 coex_sta->crc_err_11n = 0; 297 coex_sta->crc_err_11n_agg = 0; 298 } else { 299 coex_sta->crc_ok_cck = 300 btcoexist->btc_read_4byte(btcoexist, 0xf88); 301 coex_sta->crc_ok_11g = 302 btcoexist->btc_read_2byte(btcoexist, 0xf94); 303 coex_sta->crc_ok_11n = 304 btcoexist->btc_read_2byte(btcoexist, 0xf90); 305 coex_sta->crc_ok_11n_agg = 306 btcoexist->btc_read_2byte(btcoexist, 0xfb8); 307 308 coex_sta->crc_err_cck = 309 btcoexist->btc_read_4byte(btcoexist, 0xf84); 310 coex_sta->crc_err_11g = 311 btcoexist->btc_read_2byte(btcoexist, 0xf96); 312 coex_sta->crc_err_11n = 313 btcoexist->btc_read_2byte(btcoexist, 0xf92); 314 coex_sta->crc_err_11n_agg = 315 btcoexist->btc_read_2byte(btcoexist, 0xfba); 316 } 317 318 /* reset counter */ 319 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x1); 320 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xf16, 0x1, 0x0); 321 322 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) { 323 total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g + 324 coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_agg; 325 326 if ((coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) || 327 (coex_dm->bt_status == 328 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) || 329 (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)) { 330 if (coex_sta->crc_ok_cck > 331 (total_cnt - coex_sta->crc_ok_cck)) { 332 if (cck_lock_counter < 3) 333 cck_lock_counter++; 334 } else { 335 if (cck_lock_counter > 0) 336 cck_lock_counter--; 337 } 338 339 } else { 340 if (cck_lock_counter > 0) 341 cck_lock_counter--; 342 } 343 } else { 344 if (cck_lock_counter > 0) 345 cck_lock_counter--; 346 } 347 348 if (!coex_sta->pre_ccklock) { 349 if (cck_lock_counter >= 3) 350 coex_sta->cck_lock = true; 351 else 352 coex_sta->cck_lock = false; 353 } else { 354 if (cck_lock_counter == 0) 355 coex_sta->cck_lock = false; 356 else 357 coex_sta->cck_lock = true; 358 } 359 360 if (coex_sta->cck_lock) 361 coex_sta->cck_ever_lock = true; 362 363 coex_sta->pre_ccklock = coex_sta->cck_lock; 364 } 365 366 static bool btc8723b1ant_is_wifi_status_changed(struct btc_coexist *btcoexist) 367 { 368 static bool pre_wifi_busy; 369 static bool pre_under_4way, pre_bt_hs_on; 370 bool wifi_busy = false, under_4way = false, bt_hs_on = false; 371 bool wifi_connected = false; 372 373 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 374 &wifi_connected); 375 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 376 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 377 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 378 &under_4way); 379 380 if (wifi_connected) { 381 if (wifi_busy != pre_wifi_busy) { 382 pre_wifi_busy = wifi_busy; 383 return true; 384 } 385 if (under_4way != pre_under_4way) { 386 pre_under_4way = under_4way; 387 return true; 388 } 389 if (bt_hs_on != pre_bt_hs_on) { 390 pre_bt_hs_on = bt_hs_on; 391 return true; 392 } 393 } 394 395 return false; 396 } 397 398 static void halbtc8723b1ant_update_bt_link_info(struct btc_coexist *btcoexist) 399 { 400 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 401 bool bt_hs_on = false; 402 403 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 404 405 bt_link_info->bt_link_exist = coex_sta->bt_link_exist; 406 bt_link_info->sco_exist = coex_sta->sco_exist; 407 bt_link_info->a2dp_exist = coex_sta->a2dp_exist; 408 bt_link_info->pan_exist = coex_sta->pan_exist; 409 bt_link_info->hid_exist = coex_sta->hid_exist; 410 bt_link_info->bt_hi_pri_link_exist = coex_sta->bt_hi_pri_link_exist; 411 412 /* work around for HS mode. */ 413 if (bt_hs_on) { 414 bt_link_info->pan_exist = true; 415 bt_link_info->bt_link_exist = true; 416 } 417 418 /* check if Sco only */ 419 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 420 !bt_link_info->pan_exist && !bt_link_info->hid_exist) 421 bt_link_info->sco_only = true; 422 else 423 bt_link_info->sco_only = false; 424 425 /* check if A2dp only */ 426 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist && 427 !bt_link_info->pan_exist && !bt_link_info->hid_exist) 428 bt_link_info->a2dp_only = true; 429 else 430 bt_link_info->a2dp_only = false; 431 432 /* check if Pan only */ 433 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 434 bt_link_info->pan_exist && !bt_link_info->hid_exist) 435 bt_link_info->pan_only = true; 436 else 437 bt_link_info->pan_only = false; 438 439 /* check if Hid only */ 440 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 441 !bt_link_info->pan_exist && bt_link_info->hid_exist) 442 bt_link_info->hid_only = true; 443 else 444 bt_link_info->hid_only = false; 445 } 446 447 static void halbtc8723b1ant_set_bt_auto_report(struct btc_coexist *btcoexist, 448 bool enable_auto_report) 449 { 450 u8 h2c_parameter[1] = {0}; 451 452 h2c_parameter[0] = 0; 453 454 if (enable_auto_report) 455 h2c_parameter[0] |= BIT(0); 456 457 btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter); 458 } 459 460 static void halbtc8723b1ant_bt_auto_report(struct btc_coexist *btcoexist, 461 bool force_exec, 462 bool enable_auto_report) 463 { 464 coex_dm->cur_bt_auto_report = enable_auto_report; 465 466 if (!force_exec) { 467 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report) 468 return; 469 } 470 halbtc8723b1ant_set_bt_auto_report(btcoexist, 471 coex_dm->cur_bt_auto_report); 472 473 coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report; 474 } 475 476 static void btc8723b1ant_set_sw_pen_tx_rate_adapt(struct btc_coexist *btcoexist, 477 bool low_penalty_ra) 478 { 479 struct rtl_priv *rtlpriv = btcoexist->adapter; 480 u8 h2c_parameter[6] = {0}; 481 482 h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty */ 483 484 if (low_penalty_ra) { 485 h2c_parameter[1] |= BIT0; 486 /* normal rate except MCS7/6/5, OFDM54/48/36 */ 487 h2c_parameter[2] = 0x00; 488 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */ 489 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */ 490 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */ 491 } 492 493 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 494 "[BTCoex], set WiFi Low-Penalty Retry: %s", 495 (low_penalty_ra ? "ON!!" : "OFF!!")); 496 497 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter); 498 } 499 500 static void halbtc8723b1ant_low_penalty_ra(struct btc_coexist *btcoexist, 501 bool force_exec, bool low_penalty_ra) 502 { 503 coex_dm->cur_low_penalty_ra = low_penalty_ra; 504 505 if (!force_exec) { 506 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra) 507 return; 508 } 509 btc8723b1ant_set_sw_pen_tx_rate_adapt(btcoexist, 510 coex_dm->cur_low_penalty_ra); 511 512 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra; 513 } 514 515 static void halbtc8723b1ant_set_coex_table(struct btc_coexist *btcoexist, 516 u32 val0x6c0, u32 val0x6c4, 517 u32 val0x6c8, u8 val0x6cc) 518 { 519 struct rtl_priv *rtlpriv = btcoexist->adapter; 520 521 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 522 "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0); 523 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0); 524 525 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 526 "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4); 527 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4); 528 529 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 530 "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8); 531 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8); 532 533 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 534 "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc); 535 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc); 536 } 537 538 static void halbtc8723b1ant_coex_table(struct btc_coexist *btcoexist, 539 bool force_exec, u32 val0x6c0, 540 u32 val0x6c4, u32 val0x6c8, 541 u8 val0x6cc) 542 { 543 struct rtl_priv *rtlpriv = btcoexist->adapter; 544 545 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 546 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6cc = 0x%x\n", 547 (force_exec ? "force to" : ""), 548 val0x6c0, val0x6c4, val0x6cc); 549 coex_dm->cur_val0x6c0 = val0x6c0; 550 coex_dm->cur_val0x6c4 = val0x6c4; 551 coex_dm->cur_val0x6c8 = val0x6c8; 552 coex_dm->cur_val0x6cc = val0x6cc; 553 554 if (!force_exec) { 555 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) && 556 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) && 557 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) && 558 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc)) 559 return; 560 } 561 halbtc8723b1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, 562 val0x6c8, val0x6cc); 563 564 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0; 565 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4; 566 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8; 567 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc; 568 } 569 570 static void halbtc8723b1ant_coex_table_with_type(struct btc_coexist *btcoexist, 571 bool force_exec, u8 type) 572 { 573 coex_sta->coex_table_type = type; 574 575 switch (type) { 576 case 0: 577 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555, 578 0x55555555, 0xffffff, 0x3); 579 break; 580 case 1: 581 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555, 582 0x5a5a5a5a, 0xffffff, 0x3); 583 break; 584 case 2: 585 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a, 586 0x5a5a5a5a, 0xffffff, 0x3); 587 break; 588 case 3: 589 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555, 590 0x5a5a5a5a, 0xffffff, 0x3); 591 break; 592 case 4: 593 if ((coex_sta->cck_ever_lock) && (coex_sta->scan_ap_num <= 5)) 594 halbtc8723b1ant_coex_table(btcoexist, force_exec, 595 0x55555555, 0xaaaa5a5a, 596 0xffffff, 0x3); 597 else 598 halbtc8723b1ant_coex_table(btcoexist, force_exec, 599 0x55555555, 0x5a5a5a5a, 600 0xffffff, 0x3); 601 break; 602 case 5: 603 if ((coex_sta->cck_ever_lock) && (coex_sta->scan_ap_num <= 5)) 604 halbtc8723b1ant_coex_table(btcoexist, force_exec, 605 0x5a5a5a5a, 0x5aaa5a5a, 606 0xffffff, 0x3); 607 else 608 halbtc8723b1ant_coex_table(btcoexist, force_exec, 609 0x5a5a5a5a, 0x5aaa5a5a, 610 0xffffff, 0x3); 611 break; 612 case 6: 613 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55555555, 614 0xaaaaaaaa, 0xffffff, 0x3); 615 break; 616 case 7: 617 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa, 618 0xaaaaaaaa, 0xffffff, 0x3); 619 break; 620 case 8: 621 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 622 0x5ada5ada, 0xffffff, 0x3); 623 break; 624 case 9: 625 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 626 0x5ada5ada, 0xffffff, 0x3); 627 break; 628 case 10: 629 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 630 0x5ada5ada, 0xffffff, 0x3); 631 break; 632 case 11: 633 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 634 0x5ada5ada, 0xffffff, 0x3); 635 break; 636 case 12: 637 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 638 0x5ada5ada, 0xffffff, 0x3); 639 break; 640 case 13: 641 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff, 642 0xaaaaaaaa, 0xffffff, 0x3); 643 break; 644 case 14: 645 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x5fff5fff, 646 0x5ada5ada, 0xffffff, 0x3); 647 break; 648 case 15: 649 halbtc8723b1ant_coex_table(btcoexist, force_exec, 0x55dd55dd, 650 0xaaaaaaaa, 0xffffff, 0x3); 651 break; 652 default: 653 break; 654 } 655 } 656 657 static void 658 halbtc8723b1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist, 659 bool enable) 660 { 661 struct rtl_priv *rtlpriv = btcoexist->adapter; 662 u8 h2c_parameter[1] = {0}; 663 664 if (enable) 665 h2c_parameter[0] |= BIT0; /* function enable */ 666 667 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 668 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n", 669 h2c_parameter[0]); 670 671 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter); 672 } 673 674 static void halbtc8723b1ant_ignore_wlan_act(struct btc_coexist *btcoexist, 675 bool force_exec, bool enable) 676 { 677 struct rtl_priv *rtlpriv = btcoexist->adapter; 678 679 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 680 "[BTCoex], %s turn Ignore WlanAct %s\n", 681 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF")); 682 coex_dm->cur_ignore_wlan_act = enable; 683 684 if (!force_exec) { 685 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 686 "[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n", 687 coex_dm->pre_ignore_wlan_act, 688 coex_dm->cur_ignore_wlan_act); 689 690 if (coex_dm->pre_ignore_wlan_act == 691 coex_dm->cur_ignore_wlan_act) 692 return; 693 } 694 halbtc8723b1ant_set_fw_ignore_wlan_act(btcoexist, enable); 695 696 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act; 697 } 698 699 static void halbtc8723b1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, 700 u8 byte1, u8 byte2, u8 byte3, 701 u8 byte4, u8 byte5) 702 { 703 struct rtl_priv *rtlpriv = btcoexist->adapter; 704 u8 h2c_parameter[5] = {0}; 705 u8 real_byte1 = byte1, real_byte5 = byte5; 706 bool ap_enable = false; 707 708 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, 709 &ap_enable); 710 711 if (ap_enable) { 712 if ((byte1 & BIT4) && !(byte1 & BIT5)) { 713 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 714 "[BTCoex], FW for 1Ant AP mode\n"); 715 real_byte1 &= ~BIT4; 716 real_byte1 |= BIT5; 717 718 real_byte5 |= BIT5; 719 real_byte5 &= ~BIT6; 720 } 721 } 722 723 h2c_parameter[0] = real_byte1; 724 h2c_parameter[1] = byte2; 725 h2c_parameter[2] = byte3; 726 h2c_parameter[3] = byte4; 727 h2c_parameter[4] = real_byte5; 728 729 coex_dm->ps_tdma_para[0] = real_byte1; 730 coex_dm->ps_tdma_para[1] = byte2; 731 coex_dm->ps_tdma_para[2] = byte3; 732 coex_dm->ps_tdma_para[3] = byte4; 733 coex_dm->ps_tdma_para[4] = real_byte5; 734 735 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 736 "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n", 737 h2c_parameter[0], 738 h2c_parameter[1] << 24 | 739 h2c_parameter[2] << 16 | 740 h2c_parameter[3] << 8 | 741 h2c_parameter[4]); 742 743 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter); 744 } 745 746 static void halbtc8723b1ant_set_lps_rpwm(struct btc_coexist *btcoexist, 747 u8 lps_val, u8 rpwm_val) 748 { 749 u8 lps = lps_val; 750 u8 rpwm = rpwm_val; 751 752 btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps); 753 btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm); 754 } 755 756 static void halbtc8723b1ant_lps_rpwm(struct btc_coexist *btcoexist, 757 bool force_exec, 758 u8 lps_val, u8 rpwm_val) 759 { 760 struct rtl_priv *rtlpriv = btcoexist->adapter; 761 762 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 763 "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n", 764 (force_exec ? "force to" : ""), lps_val, rpwm_val); 765 coex_dm->cur_lps = lps_val; 766 coex_dm->cur_rpwm = rpwm_val; 767 768 if (!force_exec) { 769 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 770 "[BTCoex], LPS-RxBeaconMode = 0x%x , LPS-RPWM = 0x%x!!\n", 771 coex_dm->cur_lps, coex_dm->cur_rpwm); 772 773 if ((coex_dm->pre_lps == coex_dm->cur_lps) && 774 (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) { 775 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 776 "[BTCoex], LPS-RPWM_Last = 0x%x , LPS-RPWM_Now = 0x%x!!\n", 777 coex_dm->pre_rpwm, coex_dm->cur_rpwm); 778 779 return; 780 } 781 } 782 halbtc8723b1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val); 783 784 coex_dm->pre_lps = coex_dm->cur_lps; 785 coex_dm->pre_rpwm = coex_dm->cur_rpwm; 786 } 787 788 static void halbtc8723b1ant_sw_mechanism(struct btc_coexist *btcoexist, 789 bool low_penalty_ra) 790 { 791 struct rtl_priv *rtlpriv = btcoexist->adapter; 792 793 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 794 "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra); 795 796 halbtc8723b1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra); 797 } 798 799 static void halbtc8723b1ant_set_ant_path(struct btc_coexist *btcoexist, 800 u8 ant_pos_type, bool force_exec, 801 bool init_hw_cfg, bool wifi_off) 802 { 803 struct rtl_priv *rtlpriv = btcoexist->adapter; 804 struct btc_board_info *board_info = &btcoexist->board_info; 805 u32 fw_ver = 0, u32tmp = 0, cnt_bt_cal_chk = 0; 806 bool pg_ext_switch = false; 807 bool use_ext_switch = false; 808 bool is_in_mp_mode = false; 809 u8 h2c_parameter[2] = {0}, u8tmp = 0; 810 811 coex_dm->cur_ant_pos_type = ant_pos_type; 812 813 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch); 814 /* [31:16] = fw ver, [15:0] = fw sub ver */ 815 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 816 817 if ((fw_ver < 0xc0000) || pg_ext_switch) 818 use_ext_switch = true; 819 820 if (init_hw_cfg) { 821 /* WiFi TRx Mask on */ 822 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 823 0x780); 824 /* remove due to interrupt is disabled that polling c2h will 825 * fail and delay 100ms. 826 */ 827 828 if (fw_ver >= 0x180000) { 829 /* Use H2C to set GNT_BT to HIGH */ 830 h2c_parameter[0] = 1; 831 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, 832 h2c_parameter); 833 } else { 834 /* set grant_bt to high */ 835 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18); 836 } 837 /* set wlan_act control by PTA */ 838 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); 839 840 /* BT select s0/s1 is controlled by BT */ 841 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0); 842 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x39, 0x8, 0x1); 843 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff); 844 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3); 845 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77); 846 } else if (wifi_off) { 847 if (fw_ver >= 0x180000) { 848 /* Use H2C to set GNT_BT to HIGH */ 849 h2c_parameter[0] = 1; 850 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, 851 h2c_parameter); 852 } else { 853 /* set grant_bt to high */ 854 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18); 855 } 856 /* set wlan_act to always low */ 857 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); 858 859 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, 860 &is_in_mp_mode); 861 if (!is_in_mp_mode) 862 /* BT select s0/s1 is controlled by BT */ 863 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 864 0x20, 0x0); 865 else 866 /* BT select s0/s1 is controlled by WiFi */ 867 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 868 0x20, 0x1); 869 870 /* 0x4c[24:23]=00, Set Antenna control by BT_RFE_CTRL 871 * BT Vendor 0xac=0xf002 872 */ 873 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c); 874 u32tmp &= ~BIT23; 875 u32tmp &= ~BIT24; 876 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp); 877 } else { 878 /* Use H2C to set GNT_BT to LOW */ 879 if (fw_ver >= 0x180000) { 880 if (btcoexist->btc_read_1byte(btcoexist, 0x765) != 0) { 881 h2c_parameter[0] = 0; 882 btcoexist->btc_fill_h2c(btcoexist, 0x6E, 1, 883 h2c_parameter); 884 } 885 } else { 886 /* BT calibration check */ 887 while (cnt_bt_cal_chk <= 20) { 888 u8tmp = btcoexist->btc_read_1byte(btcoexist, 889 0x49d); 890 cnt_bt_cal_chk++; 891 if (u8tmp & BIT(0)) { 892 RT_TRACE(rtlpriv, COMP_BT_COEXIST, 893 DBG_LOUD, 894 "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n", 895 cnt_bt_cal_chk); 896 mdelay(50); 897 } else { 898 RT_TRACE(rtlpriv, COMP_BT_COEXIST, 899 DBG_LOUD, 900 "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n", 901 cnt_bt_cal_chk); 902 break; 903 } 904 } 905 906 /* set grant_bt to PTA */ 907 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x0); 908 } 909 910 if (btcoexist->btc_read_1byte(btcoexist, 0x76e) != 0xc) { 911 /* set wlan_act control by PTA */ 912 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); 913 } 914 915 btcoexist->btc_write_1byte_bitmask( 916 btcoexist, 0x67, 0x20, 917 0x1); /* BT select s0/s1 is controlled by WiFi */ 918 } 919 920 if (use_ext_switch) { 921 if (init_hw_cfg) { 922 /* 0x4c[23] = 0, 0x4c[24] = 1 923 * Antenna control by WL/BT 924 */ 925 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c); 926 u32tmp &= ~BIT23; 927 u32tmp |= BIT24; 928 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp); 929 930 /* fixed internal switch S1->WiFi, S0->BT */ 931 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0); 932 933 if (board_info->btdm_ant_pos == 934 BTC_ANTENNA_AT_MAIN_PORT) { 935 /* tell firmware "no antenna inverse" */ 936 h2c_parameter[0] = 0; 937 /* ext switch type */ 938 h2c_parameter[1] = 1; 939 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 940 h2c_parameter); 941 } else { 942 /* tell firmware "antenna inverse" */ 943 h2c_parameter[0] = 1; 944 /* ext switch type */ 945 h2c_parameter[1] = 1; 946 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 947 h2c_parameter); 948 } 949 } 950 951 if (force_exec || 952 (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) { 953 /* ext switch setting */ 954 switch (ant_pos_type) { 955 case BTC_ANT_PATH_WIFI: 956 if (board_info->btdm_ant_pos == 957 BTC_ANTENNA_AT_MAIN_PORT) 958 btcoexist->btc_write_1byte_bitmask( 959 btcoexist, 0x92c, 0x3, 0x1); 960 else 961 btcoexist->btc_write_1byte_bitmask( 962 btcoexist, 0x92c, 0x3, 0x2); 963 break; 964 case BTC_ANT_PATH_BT: 965 if (board_info->btdm_ant_pos == 966 BTC_ANTENNA_AT_MAIN_PORT) 967 btcoexist->btc_write_1byte_bitmask( 968 btcoexist, 0x92c, 0x3, 0x2); 969 else 970 btcoexist->btc_write_1byte_bitmask( 971 btcoexist, 0x92c, 0x3, 0x1); 972 break; 973 default: 974 case BTC_ANT_PATH_PTA: 975 if (board_info->btdm_ant_pos == 976 BTC_ANTENNA_AT_MAIN_PORT) 977 btcoexist->btc_write_1byte_bitmask( 978 btcoexist, 0x92c, 0x3, 0x1); 979 else 980 btcoexist->btc_write_1byte_bitmask( 981 btcoexist, 0x92c, 0x3, 0x2); 982 break; 983 } 984 } 985 } else { 986 if (init_hw_cfg) { 987 /* 0x4c[23] = 1, 0x4c[24] = 0, 988 * Antenna control by 0x64 989 */ 990 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c); 991 u32tmp |= BIT23; 992 u32tmp &= ~BIT24; 993 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp); 994 995 /* Fix Ext switch Main->S1, Aux->S0 */ 996 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 997 0x0); 998 999 if (board_info->btdm_ant_pos == 1000 BTC_ANTENNA_AT_MAIN_PORT) { 1001 /* tell firmware "no antenna inverse" */ 1002 h2c_parameter[0] = 0; 1003 /* internal switch type */ 1004 h2c_parameter[1] = 0; 1005 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 1006 h2c_parameter); 1007 } else { 1008 /* tell firmware "antenna inverse" */ 1009 h2c_parameter[0] = 1; 1010 /* internal switch type */ 1011 h2c_parameter[1] = 0; 1012 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 1013 h2c_parameter); 1014 } 1015 } 1016 1017 if (force_exec || 1018 (coex_dm->cur_ant_pos_type != coex_dm->pre_ant_pos_type)) { 1019 /* internal switch setting */ 1020 switch (ant_pos_type) { 1021 case BTC_ANT_PATH_WIFI: 1022 if (board_info->btdm_ant_pos == 1023 BTC_ANTENNA_AT_MAIN_PORT) 1024 btcoexist->btc_write_4byte(btcoexist, 1025 0x948, 0x0); 1026 else 1027 btcoexist->btc_write_4byte(btcoexist, 1028 0x948, 0x280); 1029 break; 1030 case BTC_ANT_PATH_BT: 1031 if (board_info->btdm_ant_pos == 1032 BTC_ANTENNA_AT_MAIN_PORT) 1033 btcoexist->btc_write_4byte(btcoexist, 1034 0x948, 0x280); 1035 else 1036 btcoexist->btc_write_4byte(btcoexist, 1037 0x948, 0x0); 1038 break; 1039 default: 1040 case BTC_ANT_PATH_PTA: 1041 if (board_info->btdm_ant_pos == 1042 BTC_ANTENNA_AT_MAIN_PORT) 1043 btcoexist->btc_write_4byte(btcoexist, 1044 0x948, 0x200); 1045 else 1046 btcoexist->btc_write_4byte(btcoexist, 1047 0x948, 0x80); 1048 break; 1049 } 1050 } 1051 } 1052 1053 coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type; 1054 } 1055 1056 static void halbtc8723b1ant_ps_tdma(struct btc_coexist *btcoexist, 1057 bool force_exec, bool turn_on, u8 type) 1058 { 1059 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1060 bool wifi_busy = false; 1061 u8 rssi_adjust_val = 0; 1062 u8 ps_tdma_byte0_val = 0x51; 1063 u8 ps_tdma_byte3_val = 0x10; 1064 u8 ps_tdma_byte4_val = 0x50; 1065 s8 wifi_duration_adjust = 0x0; 1066 static bool pre_wifi_busy; 1067 1068 coex_dm->cur_ps_tdma_on = turn_on; 1069 coex_dm->cur_ps_tdma = type; 1070 1071 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 1072 1073 if (wifi_busy != pre_wifi_busy) { 1074 force_exec = true; 1075 pre_wifi_busy = wifi_busy; 1076 } 1077 1078 if (!force_exec) { 1079 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) && 1080 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma)) 1081 return; 1082 } 1083 1084 if (coex_sta->scan_ap_num <= 5) { 1085 wifi_duration_adjust = 5; 1086 1087 if (coex_sta->a2dp_bit_pool >= 35) 1088 wifi_duration_adjust = -10; 1089 else if (coex_sta->a2dp_bit_pool >= 45) 1090 wifi_duration_adjust = -15; 1091 } else if (coex_sta->scan_ap_num >= 40) { 1092 wifi_duration_adjust = -15; 1093 1094 if (coex_sta->a2dp_bit_pool < 35) 1095 wifi_duration_adjust = -5; 1096 else if (coex_sta->a2dp_bit_pool < 45) 1097 wifi_duration_adjust = -10; 1098 } else if (coex_sta->scan_ap_num >= 20) { 1099 wifi_duration_adjust = -10; 1100 1101 if (coex_sta->a2dp_bit_pool >= 45) 1102 wifi_duration_adjust = -15; 1103 } else { 1104 wifi_duration_adjust = 0; 1105 1106 if (coex_sta->a2dp_bit_pool >= 35) 1107 wifi_duration_adjust = -10; 1108 else if (coex_sta->a2dp_bit_pool >= 45) 1109 wifi_duration_adjust = -15; 1110 } 1111 1112 if ((type == 1) || (type == 2) || (type == 9) || (type == 11) || 1113 (type == 101) || (type == 102) || (type == 109) || (type == 101)) { 1114 if (!coex_sta->force_lps_on) { 1115 /* Native power save TDMA, only for A2DP-only case 1116 * 1/2/9/11 while wifi noisy threshold > 30 1117 */ 1118 1119 /* no null-pkt */ 1120 ps_tdma_byte0_val = 0x61; 1121 /* no tx-pause at BT-slot */ 1122 ps_tdma_byte3_val = 0x11; 1123 /* 0x778 = d/1 toggle, no dynamic slot */ 1124 ps_tdma_byte4_val = 0x10; 1125 } else { 1126 /* null-pkt */ 1127 ps_tdma_byte0_val = 0x51; 1128 /* tx-pause at BT-slot */ 1129 ps_tdma_byte3_val = 0x10; 1130 /* 0x778 = d/1 toggle, dynamic slot */ 1131 ps_tdma_byte4_val = 0x50; 1132 } 1133 } else if ((type == 3) || (type == 13) || (type == 14) || 1134 (type == 103) || (type == 113) || (type == 114)) { 1135 /* null-pkt */ 1136 ps_tdma_byte0_val = 0x51; 1137 /* tx-pause at BT-slot */ 1138 ps_tdma_byte3_val = 0x10; 1139 /* 0x778 = d/1 toggle, no dynamic slot */ 1140 ps_tdma_byte4_val = 0x10; 1141 } else { /* native power save case */ 1142 /* no null-pkt */ 1143 ps_tdma_byte0_val = 0x61; 1144 /* no tx-pause at BT-slot */ 1145 ps_tdma_byte3_val = 0x11; 1146 /* 0x778 = d/1 toggle, no dynamic slot */ 1147 ps_tdma_byte4_val = 0x11; 1148 /* psTdmaByte4Va is not define for 0x778 = d/1, 1/1 case */ 1149 } 1150 1151 /* if (bt_link_info->slave_role) */ 1152 if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist)) 1153 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */ 1154 ps_tdma_byte4_val = ps_tdma_byte4_val | 0x1; 1155 1156 if (type > 100) { 1157 /* set antenna control by SW */ 1158 ps_tdma_byte0_val = ps_tdma_byte0_val | 0x82; 1159 /* set antenna no toggle, control by antenna diversity */ 1160 ps_tdma_byte3_val = ps_tdma_byte3_val | 0x60; 1161 } 1162 1163 if (turn_on) { 1164 switch (type) { 1165 default: 1166 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1a, 1167 0x1a, 0x0, 1168 ps_tdma_byte4_val); 1169 break; 1170 case 1: 1171 halbtc8723b1ant_set_fw_ps_tdma( 1172 btcoexist, ps_tdma_byte0_val, 1173 0x3a + wifi_duration_adjust, 0x03, 1174 ps_tdma_byte3_val, ps_tdma_byte4_val); 1175 1176 rssi_adjust_val = 11; 1177 break; 1178 case 2: 1179 halbtc8723b1ant_set_fw_ps_tdma( 1180 btcoexist, ps_tdma_byte0_val, 1181 0x2d + wifi_duration_adjust, 0x03, 1182 ps_tdma_byte3_val, ps_tdma_byte4_val); 1183 break; 1184 case 3: 1185 halbtc8723b1ant_set_fw_ps_tdma( 1186 btcoexist, ps_tdma_byte0_val, 0x30, 0x03, 1187 ps_tdma_byte3_val, ps_tdma_byte4_val); 1188 break; 1189 case 4: 1190 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15, 1191 0x3, 0x14, 0x0); 1192 break; 1193 case 5: 1194 halbtc8723b1ant_set_fw_ps_tdma( 1195 btcoexist, ps_tdma_byte0_val, 0x1f, 0x3, 1196 ps_tdma_byte3_val, 0x11); 1197 break; 1198 case 6: 1199 halbtc8723b1ant_set_fw_ps_tdma( 1200 btcoexist, ps_tdma_byte0_val, 0x20, 0x3, 1201 ps_tdma_byte3_val, 0x11); 1202 break; 1203 case 7: 1204 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xc, 1205 0x5, 0x0, 0x0); 1206 break; 1207 case 8: 1208 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25, 1209 0x3, 0x10, 0x0); 1210 break; 1211 case 9: 1212 halbtc8723b1ant_set_fw_ps_tdma( 1213 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1214 ps_tdma_byte3_val, ps_tdma_byte4_val); 1215 break; 1216 case 10: 1217 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa, 1218 0xa, 0x0, 0x40); 1219 break; 1220 case 11: 1221 halbtc8723b1ant_set_fw_ps_tdma( 1222 btcoexist, ps_tdma_byte0_val, 0x21, 0x03, 1223 ps_tdma_byte3_val, ps_tdma_byte4_val); 1224 break; 1225 case 12: 1226 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x0a, 1227 0x0a, 0x0, 0x50); 1228 break; 1229 case 13: 1230 if (coex_sta->scan_ap_num <= 3) 1231 halbtc8723b1ant_set_fw_ps_tdma( 1232 btcoexist, ps_tdma_byte0_val, 0x40, 0x3, 1233 ps_tdma_byte3_val, ps_tdma_byte4_val); 1234 else 1235 halbtc8723b1ant_set_fw_ps_tdma( 1236 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1237 ps_tdma_byte3_val, ps_tdma_byte4_val); 1238 break; 1239 case 14: 1240 if (coex_sta->scan_ap_num <= 3) 1241 halbtc8723b1ant_set_fw_ps_tdma( 1242 btcoexist, 0x51, 0x30, 0x3, 0x10, 0x50); 1243 else 1244 halbtc8723b1ant_set_fw_ps_tdma( 1245 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1246 ps_tdma_byte3_val, ps_tdma_byte4_val); 1247 break; 1248 case 15: 1249 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa, 1250 0x3, 0x8, 0x0); 1251 break; 1252 case 16: 1253 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15, 1254 0x3, 0x10, 0x0); 1255 break; 1256 case 18: 1257 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25, 1258 0x3, 0x10, 0x0); 1259 break; 1260 case 20: 1261 halbtc8723b1ant_set_fw_ps_tdma( 1262 btcoexist, ps_tdma_byte0_val, 0x3f, 0x03, 1263 ps_tdma_byte3_val, 0x10); 1264 break; 1265 case 21: 1266 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25, 1267 0x03, 0x11, 0x11); 1268 break; 1269 case 22: 1270 halbtc8723b1ant_set_fw_ps_tdma( 1271 btcoexist, ps_tdma_byte0_val, 0x25, 0x03, 1272 ps_tdma_byte3_val, 0x10); 1273 break; 1274 case 23: 1275 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25, 1276 0x3, 0x31, 0x18); 1277 break; 1278 case 24: 1279 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15, 1280 0x3, 0x31, 0x18); 1281 break; 1282 case 25: 1283 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa, 1284 0x3, 0x31, 0x18); 1285 break; 1286 case 26: 1287 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa, 1288 0x3, 0x31, 0x18); 1289 break; 1290 case 27: 1291 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25, 1292 0x3, 0x31, 0x98); 1293 break; 1294 case 28: 1295 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x69, 0x25, 1296 0x3, 0x31, 0x0); 1297 break; 1298 case 29: 1299 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xab, 0x1a, 1300 0x1a, 0x1, 0x10); 1301 break; 1302 case 30: 1303 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30, 1304 0x3, 0x10, 0x10); 1305 break; 1306 case 31: 1307 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1a, 1308 0x1a, 0, 0x58); 1309 break; 1310 case 32: 1311 halbtc8723b1ant_set_fw_ps_tdma( 1312 btcoexist, ps_tdma_byte0_val, 0x35, 0x3, 1313 ps_tdma_byte3_val, ps_tdma_byte4_val); 1314 break; 1315 case 33: 1316 halbtc8723b1ant_set_fw_ps_tdma( 1317 btcoexist, ps_tdma_byte0_val, 0x35, 0x3, 1318 ps_tdma_byte3_val, 0x10); 1319 break; 1320 case 34: 1321 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x53, 0x1a, 1322 0x1a, 0x0, 0x10); 1323 break; 1324 case 35: 1325 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x63, 0x1a, 1326 0x1a, 0x0, 0x10); 1327 break; 1328 case 36: 1329 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x12, 1330 0x3, 0x14, 0x50); 1331 break; 1332 case 40: 1333 /* SoftAP only with no sta associated,BT disable ,TDMA 1334 * mode for power saving 1335 * 1336 * here softap mode screen off will cost 70-80mA for 1337 * phone 1338 */ 1339 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x23, 0x18, 1340 0x00, 0x10, 0x24); 1341 break; 1342 1343 case 101: 1344 /* for 1-Ant translate to 2-Ant */ 1345 halbtc8723b1ant_set_fw_ps_tdma( 1346 btcoexist, ps_tdma_byte0_val, 1347 0x3a + wifi_duration_adjust, 0x03, 1348 ps_tdma_byte3_val, ps_tdma_byte4_val); 1349 break; 1350 case 102: 1351 halbtc8723b1ant_set_fw_ps_tdma( 1352 btcoexist, ps_tdma_byte0_val, 1353 0x2d + wifi_duration_adjust, 0x03, 1354 ps_tdma_byte3_val, ps_tdma_byte4_val); 1355 break; 1356 case 103: 1357 halbtc8723b1ant_set_fw_ps_tdma( 1358 btcoexist, ps_tdma_byte0_val, 0x3a, 0x03, 1359 ps_tdma_byte3_val, ps_tdma_byte4_val); 1360 break; 1361 case 105: 1362 halbtc8723b1ant_set_fw_ps_tdma( 1363 btcoexist, ps_tdma_byte0_val, 0x15, 0x3, 1364 ps_tdma_byte3_val, 0x11); 1365 break; 1366 case 106: 1367 halbtc8723b1ant_set_fw_ps_tdma( 1368 btcoexist, ps_tdma_byte0_val, 0x20, 0x3, 1369 ps_tdma_byte3_val, 0x11); 1370 break; 1371 case 109: 1372 halbtc8723b1ant_set_fw_ps_tdma( 1373 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1374 ps_tdma_byte3_val, ps_tdma_byte4_val); 1375 break; 1376 case 111: 1377 halbtc8723b1ant_set_fw_ps_tdma( 1378 btcoexist, ps_tdma_byte0_val, 0x21, 0x03, 1379 ps_tdma_byte3_val, ps_tdma_byte4_val); 1380 break; 1381 case 113: 1382 halbtc8723b1ant_set_fw_ps_tdma( 1383 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1384 ps_tdma_byte3_val, ps_tdma_byte4_val); 1385 break; 1386 case 114: 1387 halbtc8723b1ant_set_fw_ps_tdma( 1388 btcoexist, ps_tdma_byte0_val, 0x21, 0x3, 1389 ps_tdma_byte3_val, ps_tdma_byte4_val); 1390 break; 1391 case 120: 1392 halbtc8723b1ant_set_fw_ps_tdma( 1393 btcoexist, ps_tdma_byte0_val, 0x3f, 0x03, 1394 ps_tdma_byte3_val, 0x10); 1395 break; 1396 case 122: 1397 halbtc8723b1ant_set_fw_ps_tdma( 1398 btcoexist, ps_tdma_byte0_val, 0x25, 0x03, 1399 ps_tdma_byte3_val, 0x10); 1400 break; 1401 case 132: 1402 halbtc8723b1ant_set_fw_ps_tdma( 1403 btcoexist, ps_tdma_byte0_val, 0x25, 0x03, 1404 ps_tdma_byte3_val, ps_tdma_byte4_val); 1405 break; 1406 case 133: 1407 halbtc8723b1ant_set_fw_ps_tdma( 1408 btcoexist, ps_tdma_byte0_val, 0x25, 0x03, 1409 ps_tdma_byte3_val, 0x11); 1410 break; 1411 } 1412 } else { 1413 /* disable PS tdma */ 1414 switch (type) { 1415 case 8: /* PTA Control */ 1416 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x8, 0x0, 1417 0x0, 0x0, 0x0); 1418 halbtc8723b1ant_set_ant_path(btcoexist, 1419 BTC_ANT_PATH_PTA, 1420 FORCE_EXEC, 1421 false, false); 1422 break; 1423 case 0: 1424 default: 1425 /* Software control, Antenna at BT side */ 1426 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 1427 0x0, 0x0, 0x0); 1428 break; 1429 case 1: /* 2-Ant, 0x778=3, antenna control by ant diversity */ 1430 halbtc8723b1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0, 1431 0x48, 0x0); 1432 break; 1433 } 1434 } 1435 rssi_adjust_val = 0; 1436 btcoexist->btc_set(btcoexist, 1437 BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, 1438 &rssi_adjust_val); 1439 1440 /* update pre state */ 1441 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on; 1442 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma; 1443 } 1444 1445 void btc8723b1ant_tdma_dur_adj_for_acl(struct btc_coexist *btcoexist, 1446 u8 wifi_status) 1447 { 1448 struct rtl_priv *rtlpriv = btcoexist->adapter; 1449 static s32 up, dn, m, n, wait_count; 1450 /* 0: no change, +1: increase WiFi duration, 1451 * -1: decrease WiFi duration 1452 */ 1453 s32 result; 1454 u8 retry_count = 0, bt_info_ext; 1455 bool wifi_busy = false; 1456 1457 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1458 "[BTCoex], TdmaDurationAdjustForAcl()\n"); 1459 1460 if (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY) 1461 wifi_busy = true; 1462 else 1463 wifi_busy = false; 1464 1465 if ((wifi_status == 1466 BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) || 1467 (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) || 1468 (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)) { 1469 if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 && 1470 coex_dm->cur_ps_tdma != 3 && coex_dm->cur_ps_tdma != 9) { 1471 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1472 true, 9); 1473 coex_dm->ps_tdma_du_adj_type = 9; 1474 1475 up = 0; 1476 dn = 0; 1477 m = 1; 1478 n = 3; 1479 result = 0; 1480 wait_count = 0; 1481 } 1482 return; 1483 } 1484 1485 if (!coex_dm->auto_tdma_adjust) { 1486 coex_dm->auto_tdma_adjust = true; 1487 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1488 "[BTCoex], first run TdmaDurationAdjust()!!\n"); 1489 1490 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2); 1491 coex_dm->ps_tdma_du_adj_type = 2; 1492 1493 up = 0; 1494 dn = 0; 1495 m = 1; 1496 n = 3; 1497 result = 0; 1498 wait_count = 0; 1499 } else { 1500 /* acquire the BT TRx retry count from BT_Info byte2 */ 1501 retry_count = coex_sta->bt_retry_cnt; 1502 bt_info_ext = coex_sta->bt_info_ext; 1503 1504 if ((coex_sta->low_priority_tx) > 1050 || 1505 (coex_sta->low_priority_rx) > 1250) 1506 retry_count++; 1507 1508 result = 0; 1509 wait_count++; 1510 /* no retry in the last 2-second duration */ 1511 if (retry_count == 0) { 1512 up++; 1513 dn--; 1514 1515 if (dn <= 0) 1516 dn = 0; 1517 1518 if (up >= n) { 1519 /* if retry count during continuous n*2 seconds 1520 * is 0, enlarge WiFi duration 1521 */ 1522 wait_count = 0; 1523 n = 3; 1524 up = 0; 1525 dn = 0; 1526 result = 1; 1527 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1528 "[BTCoex], Increase wifi duration!!\n"); 1529 } 1530 } else if (retry_count <= 3) { 1531 /* <=3 retry in the last 2-second duration */ 1532 up--; 1533 dn++; 1534 1535 if (up <= 0) 1536 up = 0; 1537 1538 if (dn == 2) { 1539 /* if continuous 2 retry count(every 2 seconds) 1540 * >0 and < 3, reduce WiFi duration 1541 */ 1542 if (wait_count <= 2) 1543 /* avoid loop between the two levels */ 1544 m++; 1545 else 1546 m = 1; 1547 1548 if (m >= 20) 1549 /* maximum of m = 20 ' will recheck if 1550 * need to adjust wifi duration in 1551 * maximum time interval 120 seconds 1552 */ 1553 m = 20; 1554 1555 n = 3 * m; 1556 up = 0; 1557 dn = 0; 1558 wait_count = 0; 1559 result = -1; 1560 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1561 "[BTCoex], Decrease wifi duration for retryCounter<3!!\n"); 1562 } 1563 } else { 1564 /* retry count > 3, once retry count > 3, to reduce 1565 * WiFi duration 1566 */ 1567 if (wait_count == 1) 1568 /* to avoid loop between the two levels */ 1569 m++; 1570 else 1571 m = 1; 1572 1573 if (m >= 20) 1574 /* maximum of m = 20 ' will recheck if need to 1575 * adjust wifi duration in maximum time interval 1576 * 120 seconds 1577 */ 1578 m = 20; 1579 1580 n = 3 * m; 1581 up = 0; 1582 dn = 0; 1583 wait_count = 0; 1584 result = -1; 1585 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1586 "[BTCoex], Decrease wifi duration for retryCounter>3!!\n"); 1587 } 1588 1589 if (result == -1) { 1590 if (coex_dm->cur_ps_tdma == 1) { 1591 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1592 true, 2); 1593 coex_dm->ps_tdma_du_adj_type = 2; 1594 } else if (coex_dm->cur_ps_tdma == 2) { 1595 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1596 true, 9); 1597 coex_dm->ps_tdma_du_adj_type = 9; 1598 } else if (coex_dm->cur_ps_tdma == 9) { 1599 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1600 true, 11); 1601 coex_dm->ps_tdma_du_adj_type = 11; 1602 } 1603 } else if (result == 1) { 1604 if (coex_dm->cur_ps_tdma == 11) { 1605 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1606 true, 9); 1607 coex_dm->ps_tdma_du_adj_type = 9; 1608 } else if (coex_dm->cur_ps_tdma == 9) { 1609 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1610 true, 2); 1611 coex_dm->ps_tdma_du_adj_type = 2; 1612 } else if (coex_dm->cur_ps_tdma == 2) { 1613 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1614 true, 1); 1615 coex_dm->ps_tdma_du_adj_type = 1; 1616 } 1617 } 1618 1619 if (coex_dm->cur_ps_tdma != 1 && coex_dm->cur_ps_tdma != 2 && 1620 coex_dm->cur_ps_tdma != 9 && coex_dm->cur_ps_tdma != 11) { 1621 /* recover to previous adjust type */ 1622 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1623 coex_dm->ps_tdma_du_adj_type); 1624 } 1625 } 1626 } 1627 1628 static void halbtc8723b1ant_ps_tdma_chk_pwr_save(struct btc_coexist *btcoexist, 1629 bool new_ps_state) 1630 { 1631 u8 lps_mode = 0x0; 1632 1633 btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode); 1634 1635 if (lps_mode) { 1636 /* already under LPS state */ 1637 if (new_ps_state) { 1638 /* keep state under LPS, do nothing. */ 1639 } else { 1640 /* will leave LPS state, turn off psTdma first */ 1641 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1642 false, 0); 1643 } 1644 } else { 1645 /* NO PS state */ 1646 if (new_ps_state) { 1647 /* will enter LPS state, turn off psTdma first */ 1648 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1649 false, 0); 1650 } else { 1651 /* keep state under NO PS state, do nothing. */ 1652 } 1653 } 1654 } 1655 1656 static void halbtc8723b1ant_power_save_state(struct btc_coexist *btcoexist, 1657 u8 ps_type, u8 lps_val, 1658 u8 rpwm_val) 1659 { 1660 bool low_pwr_disable = false; 1661 1662 switch (ps_type) { 1663 case BTC_PS_WIFI_NATIVE: 1664 /* recover to original 32k low power setting */ 1665 low_pwr_disable = false; 1666 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER, 1667 &low_pwr_disable); 1668 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL); 1669 coex_sta->force_lps_on = false; 1670 break; 1671 case BTC_PS_LPS_ON: 1672 halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, true); 1673 halbtc8723b1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val, 1674 rpwm_val); 1675 /* when coex force to enter LPS, do not enter 32k low power */ 1676 low_pwr_disable = true; 1677 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER, 1678 &low_pwr_disable); 1679 /* power save must executed before psTdma */ 1680 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); 1681 coex_sta->force_lps_on = true; 1682 break; 1683 case BTC_PS_LPS_OFF: 1684 halbtc8723b1ant_ps_tdma_chk_pwr_save(btcoexist, false); 1685 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); 1686 coex_sta->force_lps_on = false; 1687 break; 1688 default: 1689 break; 1690 } 1691 } 1692 1693 static void halbtc8723b1ant_action_wifi_only(struct btc_coexist *btcoexist) 1694 { 1695 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); 1696 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 1697 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 1698 FORCE_EXEC, false, false); 1699 } 1700 1701 /* check if BT is disabled */ 1702 static void halbtc8723b1ant_monitor_bt_enable_disable(struct btc_coexist 1703 *btcoexist) 1704 { 1705 struct rtl_priv *rtlpriv = btcoexist->adapter; 1706 static u32 bt_disable_cnt; 1707 bool bt_active = true, bt_disabled = false; 1708 1709 if (coex_sta->high_priority_tx == 0 && 1710 coex_sta->high_priority_rx == 0 && coex_sta->low_priority_tx == 0 && 1711 coex_sta->low_priority_rx == 0) 1712 bt_active = false; 1713 if (coex_sta->high_priority_tx == 0xffff && 1714 coex_sta->high_priority_rx == 0xffff && 1715 coex_sta->low_priority_tx == 0xffff && 1716 coex_sta->low_priority_rx == 0xffff) 1717 bt_active = false; 1718 if (bt_active) { 1719 bt_disable_cnt = 0; 1720 bt_disabled = false; 1721 } else { 1722 bt_disable_cnt++; 1723 if (bt_disable_cnt >= 2) 1724 bt_disabled = true; 1725 } 1726 if (coex_sta->bt_disabled != bt_disabled) { 1727 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 1728 "[BTCoex], BT is from %s to %s!!\n", 1729 (coex_sta->bt_disabled ? "disabled" : "enabled"), 1730 (bt_disabled ? "disabled" : "enabled")); 1731 1732 coex_sta->bt_disabled = bt_disabled; 1733 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE, 1734 &bt_disabled); 1735 if (bt_disabled) { 1736 halbtc8723b1ant_action_wifi_only(btcoexist); 1737 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, 1738 NULL); 1739 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, 1740 NULL); 1741 } 1742 } 1743 } 1744 1745 /***************************************************** 1746 * 1747 * Non-Software Coex Mechanism start 1748 * 1749 *****************************************************/ 1750 1751 static void halbtc8723b1ant_action_bt_whck_test(struct btc_coexist *btcoexist) 1752 { 1753 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 1754 0x0); 1755 1756 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1757 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC, 1758 false, false); 1759 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0); 1760 } 1761 1762 static void halbtc8723b1ant_action_wifi_multiport(struct btc_coexist *btcoexist) 1763 { 1764 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1765 0x0, 0x0); 1766 1767 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1768 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC, 1769 false, false); 1770 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1771 } 1772 1773 static void halbtc8723b1ant_action_hs(struct btc_coexist *btcoexist) 1774 { 1775 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5); 1776 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1777 } 1778 1779 static void halbtc8723b1ant_action_bt_inquiry(struct btc_coexist *btcoexist) 1780 { 1781 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1782 bool wifi_connected = false, ap_enable = false; 1783 bool wifi_busy = false, bt_busy = false; 1784 1785 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, 1786 &ap_enable); 1787 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 1788 &wifi_connected); 1789 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 1790 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy); 1791 1792 if (coex_sta->bt_abnormal_scan) { 1793 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33); 1794 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7); 1795 } else if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) { 1796 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1797 0x0, 0x0); 1798 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1799 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 1800 NORMAL_EXEC, false, false); 1801 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0); 1802 } else if (bt_link_info->sco_exist || bt_link_info->hid_exist || 1803 bt_link_info->a2dp_exist) { 1804 /* SCO/HID/A2DP busy */ 1805 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1806 0x0, 0x0); 1807 if (coex_sta->c2h_bt_remote_name_req) 1808 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1809 33); 1810 else 1811 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1812 32); 1813 1814 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1815 } else if (bt_link_info->pan_exist || wifi_busy) { 1816 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1817 0x0, 0x0); 1818 if (coex_sta->c2h_bt_remote_name_req) 1819 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1820 33); 1821 else 1822 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1823 32); 1824 1825 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1826 } else { 1827 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1828 0x0, 0x0); 1829 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1830 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 1831 NORMAL_EXEC, false, false); 1832 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7); 1833 } 1834 } 1835 1836 static void btc8723b1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist, 1837 u8 wifi_status) 1838 { 1839 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1840 bool wifi_connected = false; 1841 1842 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 1843 &wifi_connected); 1844 1845 /* tdma and coex table */ 1846 if (bt_link_info->sco_exist) { 1847 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5); 1848 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5); 1849 } else { 1850 /* HID */ 1851 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6); 1852 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5); 1853 } 1854 } 1855 1856 static void halbtc8723b1ant_action_wifi_connected_bt_acl_busy( 1857 struct btc_coexist *btcoexist, 1858 u8 wifi_status) 1859 { 1860 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1861 1862 if ((coex_sta->low_priority_rx >= 950) && (!coex_sta->under_ips)) 1863 bt_link_info->slave_role = true; 1864 else 1865 bt_link_info->slave_role = false; 1866 1867 if (bt_link_info->hid_only) { /* HID */ 1868 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, wifi_status); 1869 coex_dm->auto_tdma_adjust = false; 1870 return; 1871 } else if (bt_link_info->a2dp_only) { /* A2DP */ 1872 if (wifi_status == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) { 1873 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1874 true, 32); 1875 halbtc8723b1ant_coex_table_with_type(btcoexist, 1876 NORMAL_EXEC, 4); 1877 coex_dm->auto_tdma_adjust = false; 1878 } else { 1879 btc8723b1ant_tdma_dur_adj_for_acl(btcoexist, 1880 wifi_status); 1881 halbtc8723b1ant_coex_table_with_type(btcoexist, 1882 NORMAL_EXEC, 1); 1883 coex_dm->auto_tdma_adjust = true; 1884 } 1885 } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) || 1886 (bt_link_info->hid_exist && bt_link_info->a2dp_exist && 1887 bt_link_info->pan_exist)) { 1888 /* A2DP + PAN(OPP,FTP), HID + A2DP + PAN(OPP,FTP) */ 1889 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13); 1890 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1891 coex_dm->auto_tdma_adjust = false; 1892 } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) { 1893 /* HID + A2DP */ 1894 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1895 coex_dm->auto_tdma_adjust = false; 1896 1897 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1898 } else if (bt_link_info->pan_only || 1899 (bt_link_info->hid_exist && bt_link_info->pan_exist)) { 1900 /* PAN(OPP,FTP), HID + PAN(OPP,FTP) */ 1901 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 1902 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1903 coex_dm->auto_tdma_adjust = false; 1904 } else { 1905 /* BT no-profile busy (0x9) */ 1906 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 33); 1907 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 1908 coex_dm->auto_tdma_adjust = false; 1909 } 1910 } 1911 1912 static void btc8723b1ant_action_wifi_not_conn(struct btc_coexist *btcoexist) 1913 { 1914 /* power save state */ 1915 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1916 0x0, 0x0); 1917 1918 /* tdma and coex table */ 1919 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 1920 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, NORMAL_EXEC, 1921 false, false); 1922 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0); 1923 } 1924 1925 static void 1926 btc8723b1ant_action_wifi_not_conn_scan(struct btc_coexist *btcoexist) 1927 { 1928 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1929 1930 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1931 0x0, 0x0); 1932 1933 /* tdma and coex table */ 1934 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) { 1935 if (bt_link_info->a2dp_exist) { 1936 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1937 true, 32); 1938 halbtc8723b1ant_coex_table_with_type(btcoexist, 1939 NORMAL_EXEC, 4); 1940 } else if (bt_link_info->a2dp_exist) { 1941 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1942 true, 22); 1943 halbtc8723b1ant_coex_table_with_type(btcoexist, 1944 NORMAL_EXEC, 4); 1945 } else { 1946 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1947 true, 20); 1948 halbtc8723b1ant_coex_table_with_type(btcoexist, 1949 NORMAL_EXEC, 1); 1950 } 1951 } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY || 1952 coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY){ 1953 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, 1954 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN); 1955 } else { 1956 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1957 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 1958 NORMAL_EXEC, false, false); 1959 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 1960 } 1961 } 1962 1963 static void 1964 btc8723b1ant_act_wifi_not_conn_asso_auth(struct btc_coexist *btcoexist) 1965 { 1966 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1967 1968 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1969 0x0, 0x0); 1970 1971 /* tdma and coex table */ 1972 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) || 1973 (bt_link_info->a2dp_exist)) { 1974 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32); 1975 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4); 1976 } else if (bt_link_info->pan_exist) { 1977 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20); 1978 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 4); 1979 } else { 1980 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 1981 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 1982 NORMAL_EXEC, false, false); 1983 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2); 1984 } 1985 } 1986 1987 static void btc8723b1ant_action_wifi_conn_scan(struct btc_coexist *btcoexist) 1988 { 1989 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 1990 1991 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 1992 0x0, 0x0); 1993 1994 /* tdma and coex table */ 1995 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) { 1996 if (bt_link_info->a2dp_exist) { 1997 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 1998 true, 32); 1999 halbtc8723b1ant_coex_table_with_type(btcoexist, 2000 NORMAL_EXEC, 4); 2001 } else if (bt_link_info->a2dp_exist && 2002 bt_link_info->pan_exist) { 2003 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 2004 true, 22); 2005 halbtc8723b1ant_coex_table_with_type(btcoexist, 2006 NORMAL_EXEC, 4); 2007 } else { 2008 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 2009 true, 20); 2010 halbtc8723b1ant_coex_table_with_type(btcoexist, 2011 NORMAL_EXEC, 4); 2012 } 2013 } else if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY || 2014 coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) { 2015 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, 2016 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN); 2017 } else { 2018 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 2019 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2020 NORMAL_EXEC, false, false); 2021 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 2022 } 2023 } 2024 2025 static void halbtc8723b1ant_action_wifi_connected_special_packet( 2026 struct btc_coexist *btcoexist) 2027 { 2028 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 2029 bool wifi_busy = false; 2030 2031 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 2032 2033 /* no special packet process for both WiFi and BT very busy */ 2034 if ((wifi_busy) && 2035 ((bt_link_info->pan_exist) || (coex_sta->num_of_profile >= 2))) 2036 return; 2037 2038 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 2039 0x0, 0x0); 2040 2041 /* tdma and coex table */ 2042 if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) { 2043 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32); 2044 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5); 2045 } else if (bt_link_info->a2dp_exist) { 2046 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32); 2047 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 2048 } else if (bt_link_info->pan_exist) { 2049 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20); 2050 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4); 2051 } else { 2052 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8); 2053 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2054 NORMAL_EXEC, false, false); 2055 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 2056 } 2057 } 2058 2059 static void halbtc8723b1ant_action_wifi_connected(struct btc_coexist *btcoexist) 2060 { 2061 struct rtl_priv *rtlpriv = btcoexist->adapter; 2062 bool wifi_busy = false; 2063 bool scan = false, link = false, roam = false; 2064 bool under_4way = false, ap_enable = false; 2065 2066 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2067 "[BTCoex], CoexForWifiConnect()===>\n"); 2068 2069 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 2070 &under_4way); 2071 if (under_4way) { 2072 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist); 2073 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2074 "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n"); 2075 return; 2076 } 2077 2078 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2079 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2080 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2081 2082 if (scan || link || roam) { 2083 if (scan) 2084 btc8723b1ant_action_wifi_conn_scan(btcoexist); 2085 else 2086 halbtc8723b1ant_action_wifi_connected_special_packet( 2087 btcoexist); 2088 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2089 "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n"); 2090 return; 2091 } 2092 2093 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, 2094 &ap_enable); 2095 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 2096 /* power save state */ 2097 if (!ap_enable && 2098 coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY && 2099 !btcoexist->bt_link_info.hid_only) { 2100 if (btcoexist->bt_link_info.a2dp_only) { 2101 if (!wifi_busy) { 2102 halbtc8723b1ant_power_save_state(btcoexist, 2103 BTC_PS_WIFI_NATIVE, 2104 0x0, 0x0); 2105 } else { /* busy */ 2106 if (coex_sta->scan_ap_num >= 2107 BT_8723B_1ANT_WIFI_NOISY_THRESH) 2108 /* no force LPS, no PS-TDMA, 2109 * use pure TDMA 2110 */ 2111 halbtc8723b1ant_power_save_state( 2112 btcoexist, BTC_PS_WIFI_NATIVE, 2113 0x0, 0x0); 2114 else 2115 halbtc8723b1ant_power_save_state( 2116 btcoexist, BTC_PS_LPS_ON, 0x50, 2117 0x4); 2118 } 2119 } else if ((!coex_sta->pan_exist) && (!coex_sta->a2dp_exist) && 2120 (!coex_sta->hid_exist)) 2121 halbtc8723b1ant_power_save_state( 2122 btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0); 2123 else 2124 halbtc8723b1ant_power_save_state(btcoexist, 2125 BTC_PS_LPS_ON, 2126 0x50, 0x4); 2127 } else { 2128 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 2129 0x0, 0x0); 2130 } 2131 /* tdma and coex table */ 2132 if (!wifi_busy) { 2133 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) { 2134 halbtc8723b1ant_action_wifi_connected_bt_acl_busy( 2135 btcoexist, 2136 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE); 2137 } else if (coex_dm->bt_status == 2138 BT_8723B_1ANT_BT_STATUS_SCO_BUSY || 2139 coex_dm->bt_status == 2140 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) { 2141 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, 2142 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE); 2143 } else { 2144 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 2145 false, 8); 2146 halbtc8723b1ant_set_ant_path(btcoexist, 2147 BTC_ANT_PATH_PTA, 2148 NORMAL_EXEC, false, false); 2149 halbtc8723b1ant_coex_table_with_type(btcoexist, 2150 NORMAL_EXEC, 2); 2151 } 2152 } else { 2153 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) { 2154 halbtc8723b1ant_action_wifi_connected_bt_acl_busy( 2155 btcoexist, 2156 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY); 2157 } else if (coex_dm->bt_status == 2158 BT_8723B_1ANT_BT_STATUS_SCO_BUSY || 2159 coex_dm->bt_status == 2160 BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) { 2161 btc8723b1ant_act_bt_sco_hid_only_busy(btcoexist, 2162 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY); 2163 } else { 2164 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, 2165 true, 32); 2166 halbtc8723b1ant_set_ant_path(btcoexist, 2167 BTC_ANT_PATH_PTA, 2168 NORMAL_EXEC, false, false); 2169 halbtc8723b1ant_coex_table_with_type(btcoexist, 2170 NORMAL_EXEC, 4); 2171 } 2172 } 2173 } 2174 2175 static void halbtc8723b1ant_run_coexist_mechanism(struct btc_coexist *btcoexist) 2176 { 2177 struct rtl_priv *rtlpriv = btcoexist->adapter; 2178 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 2179 bool wifi_connected = false, bt_hs_on = false, wifi_busy = false; 2180 bool increase_scan_dev_num = false; 2181 bool bt_ctrl_agg_buf_size = false; 2182 bool miracast_plus_bt = false; 2183 u8 agg_buf_size = 5; 2184 u8 iot_peer = BTC_IOT_PEER_UNKNOWN; 2185 u32 wifi_link_status = 0; 2186 u32 num_of_wifi_link = 0; 2187 u32 wifi_bw; 2188 2189 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2190 "[BTCoex], RunCoexistMechanism()===>\n"); 2191 2192 if (btcoexist->manual_control) { 2193 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2194 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n"); 2195 return; 2196 } 2197 2198 if (btcoexist->stop_coex_dm) { 2199 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2200 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n"); 2201 return; 2202 } 2203 2204 if (coex_sta->under_ips) { 2205 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2206 "[BTCoex], wifi is under IPS !!!\n"); 2207 return; 2208 } 2209 2210 if (coex_sta->bt_whck_test) { 2211 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2212 "[BTCoex], wifi is under IPS !!!\n"); 2213 halbtc8723b1ant_action_bt_whck_test(btcoexist); 2214 return; 2215 } 2216 2217 if (coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_BUSY || 2218 coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_SCO_BUSY || 2219 coex_dm->bt_status == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) 2220 increase_scan_dev_num = true; 2221 2222 btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM, 2223 &increase_scan_dev_num); 2224 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 2225 &wifi_connected); 2226 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 2227 2228 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2229 &wifi_link_status); 2230 num_of_wifi_link = wifi_link_status >> 16; 2231 2232 if (num_of_wifi_link >= 2 || 2233 wifi_link_status & WIFI_P2P_GO_CONNECTED) { 2234 if (bt_link_info->bt_link_exist) { 2235 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 2236 0, 1); 2237 miracast_plus_bt = true; 2238 } else { 2239 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 2240 0, 0); 2241 miracast_plus_bt = false; 2242 } 2243 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT, 2244 &miracast_plus_bt); 2245 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2246 bt_ctrl_agg_buf_size, agg_buf_size); 2247 2248 if ((bt_link_info->a2dp_exist || wifi_busy) && 2249 (coex_sta->c2h_bt_inquiry_page)) 2250 halbtc8723b1ant_action_bt_inquiry(btcoexist); 2251 else 2252 halbtc8723b1ant_action_wifi_multiport(btcoexist); 2253 2254 return; 2255 } 2256 2257 miracast_plus_bt = false; 2258 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT, 2259 &miracast_plus_bt); 2260 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2261 2262 if (bt_link_info->bt_link_exist && wifi_connected) { 2263 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 1, 1, 0, 1); 2264 2265 btcoexist->btc_get(btcoexist, BTC_GET_U1_IOT_PEER, &iot_peer); 2266 2267 if (iot_peer != BTC_IOT_PEER_CISCO && 2268 iot_peer != BTC_IOT_PEER_BROADCOM) { 2269 if (bt_link_info->sco_exist) 2270 halbtc8723b1ant_limited_rx(btcoexist, 2271 NORMAL_EXEC, false, 2272 false, 0x5); 2273 else 2274 halbtc8723b1ant_limited_rx(btcoexist, 2275 NORMAL_EXEC, false, 2276 false, 0x5); 2277 } else { 2278 if (bt_link_info->sco_exist) { 2279 halbtc8723b1ant_limited_rx(btcoexist, 2280 NORMAL_EXEC, true, 2281 false, 0x5); 2282 } else { 2283 if (wifi_bw == BTC_WIFI_BW_HT40) 2284 halbtc8723b1ant_limited_rx( 2285 btcoexist, NORMAL_EXEC, false, 2286 true, 0x10); 2287 else 2288 halbtc8723b1ant_limited_rx( 2289 btcoexist, NORMAL_EXEC, false, 2290 true, 0x8); 2291 } 2292 } 2293 2294 halbtc8723b1ant_sw_mechanism(btcoexist, true); 2295 } else { 2296 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2297 2298 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 2299 0x5); 2300 2301 halbtc8723b1ant_sw_mechanism(btcoexist, false); 2302 } 2303 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2304 2305 if (coex_sta->c2h_bt_inquiry_page) { 2306 halbtc8723b1ant_action_bt_inquiry(btcoexist); 2307 return; 2308 } else if (bt_hs_on) { 2309 halbtc8723b1ant_action_hs(btcoexist); 2310 return; 2311 } 2312 2313 if (!wifi_connected) { 2314 bool scan = false, link = false, roam = false; 2315 2316 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2317 "[BTCoex], wifi is non connected-idle !!!\n"); 2318 2319 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2320 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2321 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2322 2323 if (scan || link || roam) { 2324 if (scan) 2325 btc8723b1ant_action_wifi_not_conn_scan( 2326 btcoexist); 2327 else 2328 btc8723b1ant_act_wifi_not_conn_asso_auth( 2329 btcoexist); 2330 } else { 2331 btc8723b1ant_action_wifi_not_conn(btcoexist); 2332 } 2333 } else { /* wifi LPS/Busy */ 2334 halbtc8723b1ant_action_wifi_connected(btcoexist); 2335 } 2336 } 2337 2338 /* force coex mechanism to reset */ 2339 static void halbtc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist) 2340 { 2341 /* sw all off */ 2342 halbtc8723b1ant_sw_mechanism(btcoexist, false); 2343 2344 coex_sta->pop_event_cnt = 0; 2345 } 2346 2347 static void halbtc8723b1ant_init_hw_config(struct btc_coexist *btcoexist, 2348 bool backup, bool wifi_only) 2349 { 2350 struct rtl_priv *rtlpriv = btcoexist->adapter; 2351 u32 u32tmp = 0; 2352 u8 u8tmpa = 0, u8tmpb = 0; 2353 2354 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2355 "[BTCoex], 1Ant Init HW Config!!\n"); 2356 2357 /* 0xf0[15:12] --> Chip Cut information */ 2358 coex_sta->cut_version = 2359 (btcoexist->btc_read_1byte(btcoexist, 0xf1) & 0xf0) >> 4; 2360 /* enable TBTT interrupt */ 2361 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8, 0x1); 2362 2363 /* 0x790[5:0] = 0x5 */ 2364 btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5); 2365 2366 /* Enable counter statistics */ 2367 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1); 2368 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1); 2369 2370 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 2371 2372 /* Antenna config */ 2373 if (wifi_only) 2374 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI, 2375 FORCE_EXEC, true, false); 2376 else 2377 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, 2378 FORCE_EXEC, true, false); 2379 2380 /* PTA parameter */ 2381 halbtc8723b1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0); 2382 2383 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948); 2384 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765); 2385 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67); 2386 2387 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2388 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n", 2389 u32tmp, u8tmpa, u8tmpb); 2390 } 2391 2392 /************************************************************** 2393 * extern function start with ex_btc8723b1ant_ 2394 **************************************************************/ 2395 void ex_btc8723b1ant_power_on_setting(struct btc_coexist *btcoexist) 2396 { 2397 struct rtl_priv *rtlpriv = btcoexist->adapter; 2398 struct btc_board_info *board_info = &btcoexist->board_info; 2399 u8 u8tmp = 0x0; 2400 u16 u16tmp = 0x0; 2401 u32 value; 2402 2403 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2404 "xxxxxxxxxxxxxxxx Execute 8723b 1-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n"); 2405 2406 btcoexist->stop_coex_dm = true; 2407 2408 btcoexist->btc_write_1byte(btcoexist, 0x67, 0x20); 2409 2410 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */ 2411 u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2); 2412 btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT0 | BIT1); 2413 2414 /* set GRAN_BT = 1 */ 2415 btcoexist->btc_write_1byte(btcoexist, 0x765, 0x18); 2416 /* set WLAN_ACT = 0 */ 2417 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); 2418 2419 /* S0 or S1 setting and Local register setting(By the setting fw can get 2420 * ant number, S0/S1, ... info) 2421 * 2422 * Local setting bit define 2423 * BIT0: "0" for no antenna inverse; "1" for antenna inverse 2424 * BIT1: "0" for internal switch; "1" for external switch 2425 * BIT2: "0" for one antenna; "1" for two antenna 2426 * NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and 2427 * BIT2 = 0 2428 */ 2429 if (btcoexist->chip_interface == BTC_INTF_USB) { 2430 /* fixed at S0 for USB interface */ 2431 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0); 2432 2433 u8tmp |= 0x1; /* antenna inverse */ 2434 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp); 2435 2436 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT; 2437 } else { 2438 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */ 2439 if (board_info->single_ant_path == 0) { 2440 /* set to S1 */ 2441 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x280); 2442 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT; 2443 value = 1; 2444 } else if (board_info->single_ant_path == 1) { 2445 /* set to S0 */ 2446 btcoexist->btc_write_4byte(btcoexist, 0x948, 0x0); 2447 u8tmp |= 0x1; /* antenna inverse */ 2448 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT; 2449 value = 0; 2450 } 2451 2452 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL, 2453 &value); 2454 2455 if (btcoexist->chip_interface == BTC_INTF_PCI) 2456 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x384, 2457 u8tmp); 2458 else if (btcoexist->chip_interface == BTC_INTF_SDIO) 2459 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, 2460 u8tmp); 2461 } 2462 } 2463 2464 2465 void ex_btc8723b1ant_init_hwconfig(struct btc_coexist *btcoexist, 2466 bool wifi_only) 2467 { 2468 halbtc8723b1ant_init_hw_config(btcoexist, true, wifi_only); 2469 btcoexist->stop_coex_dm = false; 2470 } 2471 2472 void ex_btc8723b1ant_init_coex_dm(struct btc_coexist *btcoexist) 2473 { 2474 struct rtl_priv *rtlpriv = btcoexist->adapter; 2475 2476 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2477 "[BTCoex], Coex Mechanism Init!!\n"); 2478 2479 btcoexist->stop_coex_dm = false; 2480 2481 halbtc8723b1ant_init_coex_dm(btcoexist); 2482 2483 halbtc8723b1ant_query_bt_info(btcoexist); 2484 } 2485 2486 void ex_btc8723b1ant_display_coex_info(struct btc_coexist *btcoexist) 2487 { 2488 struct btc_board_info *board_info = &btcoexist->board_info; 2489 struct btc_stack_info *stack_info = &btcoexist->stack_info; 2490 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 2491 struct rtl_priv *rtlpriv = btcoexist->adapter; 2492 u8 u8tmp[4], i, bt_info_ext, pstdmacase = 0; 2493 u16 u16tmp[4]; 2494 u32 u32tmp[4]; 2495 bool roam = false, scan = false; 2496 bool link = false, wifi_under_5g = false; 2497 bool bt_hs_on = false, wifi_busy = false; 2498 s32 wifi_rssi = 0, bt_hs_rssi = 0; 2499 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck, wifi_link_status; 2500 u8 wifi_dot11_chnl, wifi_hs_chnl; 2501 u32 fw_ver = 0, bt_patch_ver = 0; 2502 2503 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2504 "\r\n ============[BT Coexist info]============"); 2505 2506 if (btcoexist->manual_control) { 2507 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2508 "\r\n ============[Under Manual Control]=========="); 2509 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2510 "\r\n =========================================="); 2511 } 2512 if (btcoexist->stop_coex_dm) { 2513 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2514 "\r\n ============[Coex is STOPPED]============"); 2515 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2516 "\r\n =========================================="); 2517 } 2518 2519 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d", 2520 "Ant PG Num/ Ant Mech/ Ant Pos:", 2521 board_info->pg_ant_num, board_info->btdm_ant_num, 2522 board_info->btdm_ant_pos); 2523 2524 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d", 2525 "BT stack/ hci ext ver", 2526 ((stack_info->profile_notified) ? "Yes" : "No"), 2527 stack_info->hci_version); 2528 2529 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver); 2530 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 2531 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2532 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", 2533 "CoexVer/ FwVer/ PatchVer", 2534 glcoex_ver_date_8723b_1ant, glcoex_ver_8723b_1ant, 2535 fw_ver, bt_patch_ver, bt_patch_ver); 2536 2537 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2538 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL, 2539 &wifi_dot11_chnl); 2540 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl); 2541 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)", 2542 "Dot11 channel / HsChnl(HsMode)", 2543 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on); 2544 2545 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %3ph ", 2546 "H2C Wifi inform bt chnl Info", 2547 coex_dm->wifi_chnl_info); 2548 2549 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); 2550 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi); 2551 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d", 2552 "Wifi rssi/ HS rssi", wifi_rssi, bt_hs_rssi); 2553 2554 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2555 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2556 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2557 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ", 2558 "Wifi link/ roam/ scan", link, roam, scan); 2559 2560 btcoexist->btc_get(btcoexist , BTC_GET_BL_WIFI_UNDER_5G, 2561 &wifi_under_5g); 2562 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2563 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 2564 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, 2565 &wifi_traffic_dir); 2566 2567 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ", 2568 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"), 2569 ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" : 2570 ((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20")), 2571 ((!wifi_busy) ? "idle" : 2572 ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ? 2573 "uplink" : "downlink"))); 2574 2575 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2576 &wifi_link_status); 2577 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d/ %d/ %d", 2578 "sta/vwifi/hs/p2pGo/p2pGc", 2579 ((wifi_link_status & WIFI_STA_CONNECTED) ? 1 : 0), 2580 ((wifi_link_status & WIFI_AP_CONNECTED) ? 1 : 0), 2581 ((wifi_link_status & WIFI_HS_CONNECTED) ? 1 : 0), 2582 ((wifi_link_status & WIFI_P2P_GO_CONNECTED) ? 1 : 0), 2583 ((wifi_link_status & WIFI_P2P_GC_CONNECTED) ? 1 : 0)); 2584 2585 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = [%s/ %d/ %d] ", 2586 "BT [status/ rssi/ retryCnt]", 2587 ((coex_sta->bt_disabled) ? ("disabled") : 2588 ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") : 2589 ((BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE == 2590 coex_dm->bt_status) ? 2591 "non-connected idle" : 2592 ((BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE == 2593 coex_dm->bt_status) ? 2594 "connected-idle" : "busy")))), 2595 coex_sta->bt_rssi, coex_sta->bt_retry_cnt); 2596 2597 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2598 "\r\n %-35s = %d / %d / %d / %d", 2599 "SCO/HID/PAN/A2DP", bt_link_info->sco_exist, 2600 bt_link_info->hid_exist, bt_link_info->pan_exist, 2601 bt_link_info->a2dp_exist); 2602 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO); 2603 2604 bt_info_ext = coex_sta->bt_info_ext; 2605 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s", 2606 "BT Info A2DP rate", 2607 (bt_info_ext & BIT0) ? "Basic rate" : "EDR rate"); 2608 2609 for (i = 0; i < BT_INFO_SRC_8723B_1ANT_MAX; i++) { 2610 if (coex_sta->bt_info_c2h_cnt[i]) { 2611 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2612 "\r\n %-35s = %7ph(%d)", 2613 glbt_info_src_8723b_1ant[i], 2614 coex_sta->bt_info_c2h[i], 2615 coex_sta->bt_info_c2h_cnt[i]); 2616 } 2617 } 2618 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2619 "\r\n %-35s = %s/%s, (0x%x/0x%x)", 2620 "PS state, IPS/LPS, (lps/rpwm)", 2621 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")), 2622 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")), 2623 btcoexist->bt_info.lps_val, 2624 btcoexist->bt_info.rpwm_val); 2625 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD); 2626 2627 if (!btcoexist->manual_control) { 2628 /* Sw mechanism */ 2629 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s", 2630 "============[Sw mechanism]============"); 2631 2632 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/", 2633 "SM[LowPenaltyRA]", coex_dm->cur_low_penalty_ra); 2634 2635 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/ %s/ %d ", 2636 "DelBA/ BtCtrlAgg/ AggSize", 2637 (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"), 2638 (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"), 2639 btcoexist->bt_info.agg_buf_size); 2640 2641 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ", 2642 "Rate Mask", btcoexist->bt_info.ra_mask); 2643 2644 /* Fw mechanism */ 2645 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s", 2646 "============[Fw mechanism]============"); 2647 2648 pstdmacase = coex_dm->cur_ps_tdma; 2649 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2650 "\r\n %-35s = %5ph case-%d (auto:%d)", 2651 "PS TDMA", coex_dm->ps_tdma_para, 2652 pstdmacase, coex_dm->auto_tdma_adjust); 2653 2654 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d ", 2655 "IgnWlanAct", coex_dm->cur_ignore_wlan_act); 2656 2657 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x ", 2658 "Latest error condition(should be 0)", 2659 coex_dm->error_condition); 2660 } 2661 2662 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d", 2663 "Coex Table Type", coex_sta->coex_table_type); 2664 2665 /* Hw setting */ 2666 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s", 2667 "============[Hw setting]============"); 2668 2669 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x", 2670 "backup ARFR1/ARFR2/RL/AMaxTime", coex_dm->backup_arfr_cnt1, 2671 coex_dm->backup_arfr_cnt2, coex_dm->backup_retry_limit, 2672 coex_dm->backup_ampdu_max_time); 2673 2674 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430); 2675 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434); 2676 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a); 2677 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456); 2678 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x", 2679 "0x430/0x434/0x42a/0x456", 2680 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]); 2681 2682 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778); 2683 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc); 2684 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x880); 2685 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 2686 "0x778/0x6cc/0x880[29:25]", u8tmp[0], u32tmp[0], 2687 (u32tmp[1] & 0x3e000000) >> 25); 2688 2689 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948); 2690 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67); 2691 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765); 2692 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 2693 "0x948/ 0x67[5] / 0x765", 2694 u32tmp[0], ((u8tmp[0] & 0x20) >> 5), u8tmp[1]); 2695 2696 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c); 2697 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930); 2698 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944); 2699 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 2700 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]", 2701 u32tmp[0] & 0x3, u32tmp[1] & 0xff, u32tmp[2] & 0x3); 2702 2703 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39); 2704 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40); 2705 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c); 2706 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64); 2707 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 2708 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", 2709 "0x38[11]/0x40/0x4c[24:23]/0x64[0]", 2710 ((u8tmp[0] & 0x8) >> 3), u8tmp[1], 2711 ((u32tmp[0] & 0x01800000) >> 23), u8tmp[2] & 0x1); 2712 2713 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550); 2714 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522); 2715 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x", 2716 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]); 2717 2718 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50); 2719 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c); 2720 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x", 2721 "0xc50(dig)/0x49c(null-drop)", u32tmp[0] & 0xff, u8tmp[0]); 2722 2723 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0); 2724 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4); 2725 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8); 2726 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0); 2727 2728 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b); 2729 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c); 2730 2731 fa_ofdm = ((u32tmp[0] & 0xffff0000) >> 16) + 2732 ((u32tmp[1] & 0xffff0000) >> 16) + 2733 (u32tmp[1] & 0xffff) + 2734 (u32tmp[2] & 0xffff) + 2735 ((u32tmp[3] & 0xffff0000) >> 16) + 2736 (u32tmp[3] & 0xffff); 2737 fa_cck = (u8tmp[0] << 8) + u8tmp[1]; 2738 2739 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 2740 "OFDM-CCA/OFDM-FA/CCK-FA", 2741 u32tmp[0] & 0xffff, fa_ofdm, fa_cck); 2742 2743 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0); 2744 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4); 2745 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8); 2746 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 2747 "0x6c0/0x6c4/0x6c8(coexTable)", 2748 u32tmp[0], u32tmp[1], u32tmp[2]); 2749 2750 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d", 2751 "0x770(high-pri rx/tx)", coex_sta->high_priority_rx, 2752 coex_sta->high_priority_tx); 2753 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d", 2754 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx, 2755 coex_sta->low_priority_tx); 2756 if (btcoexist->auto_report_1ant) 2757 halbtc8723b1ant_monitor_bt_ctr(btcoexist); 2758 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS); 2759 } 2760 2761 void ex_btc8723b1ant_ips_notify(struct btc_coexist *btcoexist, u8 type) 2762 { 2763 struct rtl_priv *rtlpriv = btcoexist->adapter; 2764 2765 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2766 return; 2767 2768 if (BTC_IPS_ENTER == type) { 2769 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2770 "[BTCoex], IPS ENTER notify\n"); 2771 coex_sta->under_ips = true; 2772 2773 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, 2774 FORCE_EXEC, false, true); 2775 /* set PTA control */ 2776 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0); 2777 halbtc8723b1ant_coex_table_with_type(btcoexist, 2778 NORMAL_EXEC, 0); 2779 } else if (BTC_IPS_LEAVE == type) { 2780 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2781 "[BTCoex], IPS LEAVE notify\n"); 2782 coex_sta->under_ips = false; 2783 2784 halbtc8723b1ant_init_hw_config(btcoexist, false, false); 2785 halbtc8723b1ant_init_coex_dm(btcoexist); 2786 halbtc8723b1ant_query_bt_info(btcoexist); 2787 } 2788 } 2789 2790 void ex_btc8723b1ant_lps_notify(struct btc_coexist *btcoexist, u8 type) 2791 { 2792 struct rtl_priv *rtlpriv = btcoexist->adapter; 2793 2794 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2795 return; 2796 2797 if (BTC_LPS_ENABLE == type) { 2798 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2799 "[BTCoex], LPS ENABLE notify\n"); 2800 coex_sta->under_lps = true; 2801 } else if (BTC_LPS_DISABLE == type) { 2802 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2803 "[BTCoex], LPS DISABLE notify\n"); 2804 coex_sta->under_lps = false; 2805 } 2806 } 2807 2808 void ex_btc8723b1ant_scan_notify(struct btc_coexist *btcoexist, u8 type) 2809 { 2810 struct rtl_priv *rtlpriv = btcoexist->adapter; 2811 bool wifi_connected = false, bt_hs_on = false; 2812 u8 u8tmpa, u8tmpb; 2813 u32 u32tmp; 2814 u32 wifi_link_status = 0; 2815 u32 num_of_wifi_link = 0; 2816 bool bt_ctrl_agg_buf_size = false; 2817 u8 agg_buf_size = 5; 2818 2819 if (btcoexist->manual_control || btcoexist->stop_coex_dm) 2820 return; 2821 2822 if (type == BTC_SCAN_START) { 2823 coex_sta->wifi_is_high_pri_task = true; 2824 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2825 "[BTCoex], SCAN START notify\n"); 2826 /* Force antenna setup for no scan result issue */ 2827 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 2828 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2829 FORCE_EXEC, false, false); 2830 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948); 2831 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765); 2832 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67); 2833 2834 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2835 "[BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x\n", 2836 u32tmp, u8tmpa, u8tmpb); 2837 } else { 2838 coex_sta->wifi_is_high_pri_task = false; 2839 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2840 "[BTCoex], SCAN FINISH notify\n"); 2841 2842 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, 2843 &coex_sta->scan_ap_num); 2844 } 2845 2846 if (coex_sta->bt_disabled) 2847 return; 2848 2849 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2850 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 2851 &wifi_connected); 2852 2853 halbtc8723b1ant_query_bt_info(btcoexist); 2854 2855 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2856 &wifi_link_status); 2857 num_of_wifi_link = wifi_link_status >> 16; 2858 if (num_of_wifi_link >= 2) { 2859 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2860 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2861 bt_ctrl_agg_buf_size, agg_buf_size); 2862 halbtc8723b1ant_action_wifi_multiport(btcoexist); 2863 return; 2864 } 2865 2866 if (coex_sta->c2h_bt_inquiry_page) { 2867 halbtc8723b1ant_action_bt_inquiry(btcoexist); 2868 return; 2869 } else if (bt_hs_on) { 2870 halbtc8723b1ant_action_hs(btcoexist); 2871 return; 2872 } 2873 2874 if (BTC_SCAN_START == type) { 2875 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2876 "[BTCoex], SCAN START notify\n"); 2877 if (!wifi_connected) 2878 /* non-connected scan */ 2879 btc8723b1ant_action_wifi_not_conn_scan(btcoexist); 2880 else 2881 /* wifi is connected */ 2882 btc8723b1ant_action_wifi_conn_scan(btcoexist); 2883 } else if (BTC_SCAN_FINISH == type) { 2884 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2885 "[BTCoex], SCAN FINISH notify\n"); 2886 if (!wifi_connected) 2887 /* non-connected scan */ 2888 btc8723b1ant_action_wifi_not_conn(btcoexist); 2889 else 2890 halbtc8723b1ant_action_wifi_connected(btcoexist); 2891 } 2892 } 2893 2894 void ex_btc8723b1ant_connect_notify(struct btc_coexist *btcoexist, u8 type) 2895 { 2896 struct rtl_priv *rtlpriv = btcoexist->adapter; 2897 bool wifi_connected = false, bt_hs_on = false; 2898 u32 wifi_link_status = 0; 2899 u32 num_of_wifi_link = 0; 2900 bool bt_ctrl_agg_buf_size = false, under_4way = false; 2901 u8 agg_buf_size = 5; 2902 2903 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 2904 &under_4way); 2905 2906 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 2907 coex_sta->bt_disabled) 2908 return; 2909 2910 if (type == BTC_ASSOCIATE_START) { 2911 coex_sta->wifi_is_high_pri_task = true; 2912 2913 /* Force antenna setup for no scan result issue */ 2914 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 2915 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2916 FORCE_EXEC, false, false); 2917 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2918 "[BTCoex], CONNECT START notify\n"); 2919 coex_dm->arp_cnt = 0; 2920 } else { 2921 coex_sta->wifi_is_high_pri_task = false; 2922 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2923 "[BTCoex], CONNECT FINISH notify\n"); 2924 } 2925 2926 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 2927 &wifi_link_status); 2928 num_of_wifi_link = wifi_link_status>>16; 2929 if (num_of_wifi_link >= 2) { 2930 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 2931 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 2932 bt_ctrl_agg_buf_size, agg_buf_size); 2933 halbtc8723b1ant_action_wifi_multiport(btcoexist); 2934 return; 2935 } 2936 2937 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 2938 if (coex_sta->c2h_bt_inquiry_page) { 2939 halbtc8723b1ant_action_bt_inquiry(btcoexist); 2940 return; 2941 } else if (bt_hs_on) { 2942 halbtc8723b1ant_action_hs(btcoexist); 2943 return; 2944 } 2945 2946 if (BTC_ASSOCIATE_START == type) { 2947 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2948 "[BTCoex], CONNECT START notify\n"); 2949 btc8723b1ant_act_wifi_not_conn_asso_auth(btcoexist); 2950 } else if (BTC_ASSOCIATE_FINISH == type) { 2951 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2952 "[BTCoex], CONNECT FINISH notify\n"); 2953 2954 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 2955 &wifi_connected); 2956 if (!wifi_connected) 2957 /* non-connected scan */ 2958 btc8723b1ant_action_wifi_not_conn(btcoexist); 2959 else 2960 halbtc8723b1ant_action_wifi_connected(btcoexist); 2961 } 2962 } 2963 2964 void ex_btc8723b1ant_media_status_notify(struct btc_coexist *btcoexist, 2965 u8 type) 2966 { 2967 struct rtl_priv *rtlpriv = btcoexist->adapter; 2968 u8 h2c_parameter[3] = {0}; 2969 u32 wifi_bw; 2970 u8 wifi_central_chnl; 2971 bool wifi_under_b_mode = false; 2972 2973 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 2974 coex_sta->bt_disabled) 2975 return; 2976 2977 if (type == BTC_MEDIA_CONNECT) { 2978 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 2979 "[BTCoex], MEDIA connect notify\n"); 2980 /* Force antenna setup for no scan result issue */ 2981 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8); 2982 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA, 2983 FORCE_EXEC, false, false); 2984 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, 2985 &wifi_under_b_mode); 2986 2987 /* Set CCK Tx/Rx high Pri except 11b mode */ 2988 if (wifi_under_b_mode) { 2989 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 2990 0x00); /* CCK Tx */ 2991 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 2992 0x00); /* CCK Rx */ 2993 } else { 2994 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 2995 0x00); /* CCK Tx */ 2996 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 2997 0x10); /* CCK Rx */ 2998 } 2999 3000 coex_dm->backup_arfr_cnt1 = 3001 btcoexist->btc_read_4byte(btcoexist, 0x430); 3002 coex_dm->backup_arfr_cnt2 = 3003 btcoexist->btc_read_4byte(btcoexist, 0x434); 3004 coex_dm->backup_retry_limit = 3005 btcoexist->btc_read_2byte(btcoexist, 0x42a); 3006 coex_dm->backup_ampdu_max_time = 3007 btcoexist->btc_read_1byte(btcoexist, 0x456); 3008 } else { 3009 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3010 "[BTCoex], MEDIA disconnect notify\n"); 3011 coex_dm->arp_cnt = 0; 3012 3013 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */ 3014 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */ 3015 3016 coex_sta->cck_ever_lock = false; 3017 } 3018 3019 /* only 2.4G we need to inform bt the chnl mask */ 3020 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, 3021 &wifi_central_chnl); 3022 3023 if (type == BTC_MEDIA_CONNECT && wifi_central_chnl <= 14) { 3024 h2c_parameter[0] = 0x0; 3025 h2c_parameter[1] = wifi_central_chnl; 3026 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 3027 if (BTC_WIFI_BW_HT40 == wifi_bw) 3028 h2c_parameter[2] = 0x30; 3029 else 3030 h2c_parameter[2] = 0x20; 3031 } 3032 3033 coex_dm->wifi_chnl_info[0] = h2c_parameter[0]; 3034 coex_dm->wifi_chnl_info[1] = h2c_parameter[1]; 3035 coex_dm->wifi_chnl_info[2] = h2c_parameter[2]; 3036 3037 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3038 "[BTCoex], FW write 0x66 = 0x%x\n", 3039 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 | 3040 h2c_parameter[2]); 3041 3042 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter); 3043 } 3044 3045 void ex_btc8723b1ant_special_packet_notify(struct btc_coexist *btcoexist, 3046 u8 type) 3047 { 3048 struct rtl_priv *rtlpriv = btcoexist->adapter; 3049 bool bt_hs_on = false; 3050 u32 wifi_link_status = 0; 3051 u32 num_of_wifi_link = 0; 3052 bool bt_ctrl_agg_buf_size = false, under_4way = false; 3053 u8 agg_buf_size = 5; 3054 3055 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 3056 &under_4way); 3057 3058 if (btcoexist->manual_control || btcoexist->stop_coex_dm || 3059 coex_sta->bt_disabled) 3060 return; 3061 3062 if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL || 3063 type == BTC_PACKET_ARP) { 3064 if (type == BTC_PACKET_ARP) { 3065 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3066 "[BTCoex], special Packet ARP notify\n"); 3067 3068 coex_dm->arp_cnt++; 3069 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3070 "[BTCoex], ARP Packet Count = %d\n", 3071 coex_dm->arp_cnt); 3072 3073 if ((coex_dm->arp_cnt >= 10) && (!under_4way)) 3074 /* if APR PKT > 10 after connect, do not go to 3075 * ActionWifiConnectedSpecificPacket(btcoexist) 3076 */ 3077 coex_sta->wifi_is_high_pri_task = false; 3078 else 3079 coex_sta->wifi_is_high_pri_task = true; 3080 } else { 3081 coex_sta->wifi_is_high_pri_task = true; 3082 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3083 "[BTCoex], special Packet DHCP or EAPOL notify\n"); 3084 } 3085 } else { 3086 coex_sta->wifi_is_high_pri_task = false; 3087 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3088 "[BTCoex], special Packet [Type = %d] notify\n", 3089 type); 3090 } 3091 3092 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS, 3093 &wifi_link_status); 3094 num_of_wifi_link = wifi_link_status >> 16; 3095 if (num_of_wifi_link >= 2) { 3096 halbtc8723b1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0); 3097 halbtc8723b1ant_limited_rx(btcoexist, NORMAL_EXEC, false, 3098 bt_ctrl_agg_buf_size, agg_buf_size); 3099 halbtc8723b1ant_action_wifi_multiport(btcoexist); 3100 return; 3101 } 3102 3103 coex_sta->special_pkt_period_cnt = 0; 3104 3105 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 3106 if (coex_sta->c2h_bt_inquiry_page) { 3107 halbtc8723b1ant_action_bt_inquiry(btcoexist); 3108 return; 3109 } else if (bt_hs_on) { 3110 halbtc8723b1ant_action_hs(btcoexist); 3111 return; 3112 } 3113 3114 if (BTC_PACKET_DHCP == type || 3115 BTC_PACKET_EAPOL == type) { 3116 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3117 "[BTCoex], special Packet(%d) notify\n", type); 3118 halbtc8723b1ant_action_wifi_connected_special_packet(btcoexist); 3119 } 3120 } 3121 3122 void ex_btc8723b1ant_bt_info_notify(struct btc_coexist *btcoexist, 3123 u8 *tmp_buf, u8 length) 3124 { 3125 struct rtl_priv *rtlpriv = btcoexist->adapter; 3126 u8 bt_info = 0; 3127 u8 i, rsp_source = 0; 3128 bool wifi_connected = false; 3129 bool bt_busy = false; 3130 3131 coex_sta->c2h_bt_info_req_sent = false; 3132 3133 rsp_source = tmp_buf[0] & 0xf; 3134 if (rsp_source >= BT_INFO_SRC_8723B_1ANT_MAX) 3135 rsp_source = BT_INFO_SRC_8723B_1ANT_WIFI_FW; 3136 coex_sta->bt_info_c2h_cnt[rsp_source]++; 3137 3138 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3139 "[BTCoex], Bt info[%d], length=%d, hex data = [", 3140 rsp_source, length); 3141 for (i = 0; i < length; i++) { 3142 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i]; 3143 if (i == 1) 3144 bt_info = tmp_buf[i]; 3145 if (i == length - 1) 3146 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3147 "0x%02x]\n", tmp_buf[i]); 3148 else 3149 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3150 "0x%02x, ", tmp_buf[i]); 3151 } 3152 3153 /* if 0xff, it means BT is under WHCK test */ 3154 if (bt_info == 0xff) 3155 coex_sta->bt_whck_test = true; 3156 else 3157 coex_sta->bt_whck_test = false; 3158 3159 if (rsp_source != BT_INFO_SRC_8723B_1ANT_WIFI_FW) { 3160 coex_sta->bt_retry_cnt = /* [3:0] */ 3161 coex_sta->bt_info_c2h[rsp_source][2] & 0xf; 3162 3163 if (coex_sta->bt_retry_cnt >= 1) 3164 coex_sta->pop_event_cnt++; 3165 3166 if (coex_sta->bt_info_c2h[rsp_source][2] & 0x20) 3167 coex_sta->c2h_bt_remote_name_req = true; 3168 else 3169 coex_sta->c2h_bt_remote_name_req = false; 3170 3171 coex_sta->bt_rssi = 3172 coex_sta->bt_info_c2h[rsp_source][3] * 2 - 90; 3173 3174 coex_sta->bt_info_ext = 3175 coex_sta->bt_info_c2h[rsp_source][4]; 3176 3177 if (coex_sta->bt_info_c2h[rsp_source][1] == 0x49) { 3178 coex_sta->a2dp_bit_pool = 3179 coex_sta->bt_info_c2h[rsp_source][6]; 3180 } else { 3181 coex_sta->a2dp_bit_pool = 0; 3182 } 3183 3184 coex_sta->bt_tx_rx_mask = 3185 (coex_sta->bt_info_c2h[rsp_source][2] & 0x40); 3186 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK, 3187 &coex_sta->bt_tx_rx_mask); 3188 3189 if (!coex_sta->bt_tx_rx_mask) { 3190 /* BT into is responded by BT FW and BT RF REG 3191 * 0x3C != 0x15 => Need to switch BT TRx Mask 3192 */ 3193 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3194 "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n"); 3195 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 3196 0x3c, 0x15); 3197 3198 /* BT TRx Mask lock 0x2c[0], 0x30[0] = 0 */ 3199 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 3200 0x2c, 0x7c44); 3201 btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF, 3202 0x30, 0x7c44); 3203 } 3204 3205 /* Here we need to resend some wifi info to BT 3206 * because bt is reset and loss of the info. 3207 */ 3208 if (coex_sta->bt_info_ext & BIT1) { 3209 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3210 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n"); 3211 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 3212 &wifi_connected); 3213 if (wifi_connected) 3214 ex_btc8723b1ant_media_status_notify(btcoexist, 3215 BTC_MEDIA_CONNECT); 3216 else 3217 ex_btc8723b1ant_media_status_notify(btcoexist, 3218 BTC_MEDIA_DISCONNECT); 3219 } 3220 3221 if (coex_sta->bt_info_ext & BIT3) { 3222 if (!btcoexist->manual_control && 3223 !btcoexist->stop_coex_dm) { 3224 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3225 "[BTCoex], BT ext info bit3 check, set BT NOT ignore Wlan active!!\n"); 3226 halbtc8723b1ant_ignore_wlan_act(btcoexist, 3227 FORCE_EXEC, 3228 false); 3229 } 3230 } else { 3231 /* BT already NOT ignore Wlan active, do nothing here.*/ 3232 } 3233 if (!btcoexist->auto_report_1ant) { 3234 if (coex_sta->bt_info_ext & BIT4) { 3235 /* BT auto report already enabled, do nothing */ 3236 } else { 3237 halbtc8723b1ant_bt_auto_report(btcoexist, 3238 FORCE_EXEC, 3239 true); 3240 } 3241 } 3242 } 3243 3244 /* check BIT2 first ==> check if bt is under inquiry or page scan */ 3245 if (bt_info & BT_INFO_8723B_1ANT_B_INQ_PAGE) 3246 coex_sta->c2h_bt_inquiry_page = true; 3247 else 3248 coex_sta->c2h_bt_inquiry_page = false; 3249 3250 coex_sta->num_of_profile = 0; 3251 3252 /* set link exist status */ 3253 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) { 3254 coex_sta->bt_link_exist = false; 3255 coex_sta->pan_exist = false; 3256 coex_sta->a2dp_exist = false; 3257 coex_sta->hid_exist = false; 3258 coex_sta->sco_exist = false; 3259 3260 coex_sta->bt_hi_pri_link_exist = false; 3261 } else { 3262 /* connection exists */ 3263 coex_sta->bt_link_exist = true; 3264 if (bt_info & BT_INFO_8723B_1ANT_B_FTP) { 3265 coex_sta->pan_exist = true; 3266 coex_sta->num_of_profile++; 3267 } else { 3268 coex_sta->pan_exist = false; 3269 } 3270 if (bt_info & BT_INFO_8723B_1ANT_B_A2DP) { 3271 coex_sta->a2dp_exist = true; 3272 coex_sta->num_of_profile++; 3273 } else { 3274 coex_sta->a2dp_exist = false; 3275 } 3276 if (bt_info & BT_INFO_8723B_1ANT_B_HID) { 3277 coex_sta->hid_exist = true; 3278 coex_sta->num_of_profile++; 3279 } else { 3280 coex_sta->hid_exist = false; 3281 } 3282 if (bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) { 3283 coex_sta->sco_exist = true; 3284 coex_sta->num_of_profile++; 3285 } else { 3286 coex_sta->sco_exist = false; 3287 } 3288 3289 if ((!coex_sta->hid_exist) && 3290 (!coex_sta->c2h_bt_inquiry_page) && 3291 (!coex_sta->sco_exist)) { 3292 if (coex_sta->high_priority_tx + 3293 coex_sta->high_priority_rx >= 3294 160) { 3295 coex_sta->hid_exist = true; 3296 coex_sta->wrong_profile_notification++; 3297 coex_sta->num_of_profile++; 3298 bt_info = bt_info | 0x28; 3299 } 3300 } 3301 3302 /* Add Hi-Pri Tx/Rx counter to avoid false detection */ 3303 if (((coex_sta->hid_exist) || (coex_sta->sco_exist)) && 3304 (coex_sta->high_priority_tx + coex_sta->high_priority_rx >= 3305 160) && 3306 (!coex_sta->c2h_bt_inquiry_page)) 3307 coex_sta->bt_hi_pri_link_exist = true; 3308 3309 if ((bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) && 3310 (coex_sta->num_of_profile == 0)) { 3311 if (coex_sta->low_priority_tx + 3312 coex_sta->low_priority_rx >= 3313 160) { 3314 coex_sta->pan_exist = true; 3315 coex_sta->num_of_profile++; 3316 coex_sta->wrong_profile_notification++; 3317 bt_info = bt_info | 0x88; 3318 } 3319 } 3320 } 3321 3322 halbtc8723b1ant_update_bt_link_info(btcoexist); 3323 3324 /* mask profile bit for connect-ilde identification 3325 * ( for CSR case: A2DP idle --> 0x41) 3326 */ 3327 bt_info = bt_info & 0x1f; 3328 3329 if (!(bt_info & BT_INFO_8723B_1ANT_B_CONNECTION)) { 3330 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE; 3331 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3332 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!\n"); 3333 /* connection exists but no busy */ 3334 } else if (bt_info == BT_INFO_8723B_1ANT_B_CONNECTION) { 3335 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE; 3336 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3337 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n"); 3338 } else if ((bt_info & BT_INFO_8723B_1ANT_B_SCO_ESCO) || 3339 (bt_info & BT_INFO_8723B_1ANT_B_SCO_BUSY)) { 3340 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_SCO_BUSY; 3341 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3342 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n"); 3343 } else if (bt_info & BT_INFO_8723B_1ANT_B_ACL_BUSY) { 3344 if (BT_8723B_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status) 3345 coex_dm->auto_tdma_adjust = false; 3346 3347 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_ACL_BUSY; 3348 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3349 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n"); 3350 } else { 3351 coex_dm->bt_status = BT_8723B_1ANT_BT_STATUS_MAX; 3352 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3353 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!\n"); 3354 } 3355 3356 if ((BT_8723B_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) || 3357 (BT_8723B_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || 3358 (BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) 3359 bt_busy = true; 3360 else 3361 bt_busy = false; 3362 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy); 3363 3364 halbtc8723b1ant_run_coexist_mechanism(btcoexist); 3365 } 3366 3367 void ex_btc8723b1ant_rf_status_notify(struct btc_coexist *btcoexist, u8 type) 3368 { 3369 struct rtl_priv *rtlpriv = btcoexist->adapter; 3370 u32 u32tmp; 3371 u8 u8tmpa, u8tmpb, u8tmpc; 3372 3373 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3374 "[BTCoex], RF Status notify\n"); 3375 3376 if (type == BTC_RF_ON) { 3377 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3378 "[BTCoex], RF is turned ON!!\n"); 3379 btcoexist->stop_coex_dm = false; 3380 } else if (type == BTC_RF_OFF) { 3381 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3382 "[BTCoex], RF is turned OFF!!\n"); 3383 3384 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 3385 0x0, 0x0); 3386 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0); 3387 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, 3388 FORCE_EXEC, false, true); 3389 3390 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true); 3391 btcoexist->stop_coex_dm = true; 3392 3393 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x948); 3394 u8tmpa = btcoexist->btc_read_1byte(btcoexist, 0x765); 3395 u8tmpb = btcoexist->btc_read_1byte(btcoexist, 0x67); 3396 u8tmpc = btcoexist->btc_read_1byte(btcoexist, 0x76e); 3397 3398 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3399 "############# [BTCoex], 0x948=0x%x, 0x765=0x%x, 0x67=0x%x, 0x76e=0x%x\n", 3400 u32tmp, u8tmpa, u8tmpb, u8tmpc); 3401 } 3402 } 3403 3404 void ex_btc8723b1ant_halt_notify(struct btc_coexist *btcoexist) 3405 { 3406 struct rtl_priv *rtlpriv = btcoexist->adapter; 3407 3408 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Halt notify\n"); 3409 3410 btcoexist->stop_coex_dm = true; 3411 3412 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, FORCE_EXEC, 3413 false, true); 3414 3415 halbtc8723b1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true); 3416 3417 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 3418 0x0, 0x0); 3419 halbtc8723b1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0); 3420 3421 ex_btc8723b1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT); 3422 3423 btcoexist->stop_coex_dm = true; 3424 } 3425 3426 void ex_btc8723b1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state) 3427 { 3428 struct rtl_priv *rtlpriv = btcoexist->adapter; 3429 3430 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, "[BTCoex], Pnp notify\n"); 3431 3432 if (BTC_WIFI_PNP_SLEEP == pnp_state) { 3433 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3434 "[BTCoex], Pnp notify to SLEEP\n"); 3435 halbtc8723b1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, 3436 FORCE_EXEC, false, true); 3437 halbtc8723b1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 3438 0x0, 0x0); 3439 halbtc8723b1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0); 3440 halbtc8723b1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2); 3441 3442 /* Driver do not leave IPS/LPS when driver is going to sleep, so 3443 * BTCoexistence think wifi is still under IPS/LPS 3444 * 3445 * BT should clear UnderIPS/UnderLPS state to avoid mismatch 3446 * state after wakeup. 3447 */ 3448 coex_sta->under_ips = false; 3449 coex_sta->under_lps = false; 3450 btcoexist->stop_coex_dm = true; 3451 } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) { 3452 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3453 "[BTCoex], Pnp notify to WAKE UP\n"); 3454 btcoexist->stop_coex_dm = false; 3455 halbtc8723b1ant_init_hw_config(btcoexist, false, false); 3456 halbtc8723b1ant_init_coex_dm(btcoexist); 3457 halbtc8723b1ant_query_bt_info(btcoexist); 3458 } 3459 } 3460 3461 void ex_btc8723b1ant_coex_dm_reset(struct btc_coexist *btcoexist) 3462 { 3463 struct rtl_priv *rtlpriv = btcoexist->adapter; 3464 3465 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3466 "[BTCoex], *****************Coex DM Reset****************\n"); 3467 3468 halbtc8723b1ant_init_hw_config(btcoexist, false, false); 3469 halbtc8723b1ant_init_coex_dm(btcoexist); 3470 } 3471 3472 void ex_btc8723b1ant_periodical(struct btc_coexist *btcoexist) 3473 { 3474 struct rtl_priv *rtlpriv = btcoexist->adapter; 3475 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 3476 3477 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD, 3478 "[BTCoex], ==========================Periodical===========================\n"); 3479 3480 if (!btcoexist->auto_report_1ant) { 3481 halbtc8723b1ant_query_bt_info(btcoexist); 3482 halbtc8723b1ant_monitor_bt_enable_disable(btcoexist); 3483 } else { 3484 halbtc8723b1ant_monitor_bt_ctr(btcoexist); 3485 halbtc8723b1ant_monitor_wifi_ctr(btcoexist); 3486 3487 if ((coex_sta->high_priority_tx + coex_sta->high_priority_rx < 50) && 3488 bt_link_info->hid_exist) 3489 bt_link_info->hid_exist = false; 3490 3491 if (btc8723b1ant_is_wifi_status_changed(btcoexist) || 3492 coex_dm->auto_tdma_adjust) { 3493 halbtc8723b1ant_run_coexist_mechanism(btcoexist); 3494 } 3495 coex_sta->special_pkt_period_cnt++; 3496 } 3497 } 3498