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