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