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 * Description: 27 * 28 * This file is for RTL8723B Co-exist mechanism 29 * 30 * History 31 * 2012/11/15 Cosa first check in. 32 * 33 **************************************************************/ 34 /************************************************************** 35 * include files 36 **************************************************************/ 37 #include "halbt_precomp.h" 38 /************************************************************** 39 * Global variables, these are static variables 40 **************************************************************/ 41 static struct coex_dm_8723b_2ant glcoex_dm_8723b_2ant; 42 static struct coex_dm_8723b_2ant *coex_dm = &glcoex_dm_8723b_2ant; 43 static struct coex_sta_8723b_2ant glcoex_sta_8723b_2ant; 44 static struct coex_sta_8723b_2ant *coex_sta = &glcoex_sta_8723b_2ant; 45 46 static const char *const glbt_info_src_8723b_2ant[] = { 47 "BT Info[wifi fw]", 48 "BT Info[bt rsp]", 49 "BT Info[bt auto report]", 50 }; 51 52 static u32 glcoex_ver_date_8723b_2ant = 20131113; 53 static u32 glcoex_ver_8723b_2ant = 0x3f; 54 55 /************************************************************** 56 * local function proto type if needed 57 **************************************************************/ 58 /************************************************************** 59 * local function start with btc8723b2ant_ 60 **************************************************************/ 61 static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh, 62 u8 rssi_thresh1) 63 { 64 s32 bt_rssi = 0; 65 u8 bt_rssi_state = coex_sta->pre_bt_rssi_state; 66 67 bt_rssi = coex_sta->bt_rssi; 68 69 if (level_num == 2) { 70 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) || 71 (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) { 72 if (bt_rssi >= rssi_thresh + 73 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) { 74 bt_rssi_state = BTC_RSSI_STATE_HIGH; 75 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 76 "[BTCoex], BT Rssi state " 77 "switch to High\n"); 78 } else { 79 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW; 80 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 81 "[BTCoex], BT Rssi state " 82 "stay at Low\n"); 83 } 84 } else { 85 if (bt_rssi < rssi_thresh) { 86 bt_rssi_state = BTC_RSSI_STATE_LOW; 87 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 88 "[BTCoex], BT Rssi state " 89 "switch to Low\n"); 90 } else { 91 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH; 92 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 93 "[BTCoex], BT Rssi state " 94 "stay at High\n"); 95 } 96 } 97 } else if (level_num == 3) { 98 if (rssi_thresh > rssi_thresh1) { 99 BTC_PRINT(BTC_MSG_ALGORITHM, 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_8723B_2ANT) { 108 bt_rssi_state = BTC_RSSI_STATE_MEDIUM; 109 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 110 "[BTCoex], BT Rssi state " 111 "switch to Medium\n"); 112 } else { 113 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW; 114 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 115 "[BTCoex], BT Rssi state " 116 "stay at Low\n"); 117 } 118 } else if ((coex_sta->pre_bt_rssi_state == 119 BTC_RSSI_STATE_MEDIUM) || 120 (coex_sta->pre_bt_rssi_state == 121 BTC_RSSI_STATE_STAY_MEDIUM)) { 122 if (bt_rssi >= rssi_thresh1 + 123 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) { 124 bt_rssi_state = BTC_RSSI_STATE_HIGH; 125 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 126 "[BTCoex], BT Rssi state " 127 "switch to High\n"); 128 } else if (bt_rssi < rssi_thresh) { 129 bt_rssi_state = BTC_RSSI_STATE_LOW; 130 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 131 "[BTCoex], BT Rssi state " 132 "switch to Low\n"); 133 } else { 134 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM; 135 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 136 "[BTCoex], BT Rssi state " 137 "stay at Medium\n"); 138 } 139 } else { 140 if (bt_rssi < rssi_thresh1) { 141 bt_rssi_state = BTC_RSSI_STATE_MEDIUM; 142 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 143 "[BTCoex], BT Rssi state " 144 "switch to Medium\n"); 145 } else { 146 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH; 147 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, 148 "[BTCoex], BT Rssi state " 149 "stay at High\n"); 150 } 151 } 152 } 153 154 coex_sta->pre_bt_rssi_state = bt_rssi_state; 155 156 return bt_rssi_state; 157 } 158 159 static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist, 160 u8 index, u8 level_num, 161 u8 rssi_thresh, u8 rssi_thresh1) 162 { 163 s32 wifi_rssi = 0; 164 u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index]; 165 166 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); 167 168 if (level_num == 2) { 169 if ((coex_sta->pre_wifi_rssi_state[index] == 170 BTC_RSSI_STATE_LOW) || 171 (coex_sta->pre_wifi_rssi_state[index] == 172 BTC_RSSI_STATE_STAY_LOW)) { 173 if (wifi_rssi >= rssi_thresh + 174 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) { 175 wifi_rssi_state = BTC_RSSI_STATE_HIGH; 176 BTC_PRINT(BTC_MSG_ALGORITHM, 177 ALGO_WIFI_RSSI_STATE, 178 "[BTCoex], wifi RSSI state " 179 "switch to High\n"); 180 } else { 181 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW; 182 BTC_PRINT(BTC_MSG_ALGORITHM, 183 ALGO_WIFI_RSSI_STATE, 184 "[BTCoex], wifi RSSI state " 185 "stay at Low\n"); 186 } 187 } else { 188 if (wifi_rssi < rssi_thresh) { 189 wifi_rssi_state = BTC_RSSI_STATE_LOW; 190 BTC_PRINT(BTC_MSG_ALGORITHM, 191 ALGO_WIFI_RSSI_STATE, 192 "[BTCoex], wifi RSSI state " 193 "switch to Low\n"); 194 } else { 195 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH; 196 BTC_PRINT(BTC_MSG_ALGORITHM, 197 ALGO_WIFI_RSSI_STATE, 198 "[BTCoex], wifi RSSI state " 199 "stay at High\n"); 200 } 201 } 202 } else if (level_num == 3) { 203 if (rssi_thresh > rssi_thresh1) { 204 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, 205 "[BTCoex], wifi RSSI thresh error!!\n"); 206 return coex_sta->pre_wifi_rssi_state[index]; 207 } 208 209 if ((coex_sta->pre_wifi_rssi_state[index] == 210 BTC_RSSI_STATE_LOW) || 211 (coex_sta->pre_wifi_rssi_state[index] == 212 BTC_RSSI_STATE_STAY_LOW)) { 213 if (wifi_rssi >= rssi_thresh + 214 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) { 215 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM; 216 BTC_PRINT(BTC_MSG_ALGORITHM, 217 ALGO_WIFI_RSSI_STATE, 218 "[BTCoex], wifi RSSI state " 219 "switch to Medium\n"); 220 } else { 221 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW; 222 BTC_PRINT(BTC_MSG_ALGORITHM, 223 ALGO_WIFI_RSSI_STATE, 224 "[BTCoex], wifi RSSI state " 225 "stay at Low\n"); 226 } 227 } else if ((coex_sta->pre_wifi_rssi_state[index] == 228 BTC_RSSI_STATE_MEDIUM) || 229 (coex_sta->pre_wifi_rssi_state[index] == 230 BTC_RSSI_STATE_STAY_MEDIUM)) { 231 if (wifi_rssi >= rssi_thresh1 + 232 BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) { 233 wifi_rssi_state = BTC_RSSI_STATE_HIGH; 234 BTC_PRINT(BTC_MSG_ALGORITHM, 235 ALGO_WIFI_RSSI_STATE, 236 "[BTCoex], wifi RSSI state " 237 "switch to High\n"); 238 } else if (wifi_rssi < rssi_thresh) { 239 wifi_rssi_state = BTC_RSSI_STATE_LOW; 240 BTC_PRINT(BTC_MSG_ALGORITHM, 241 ALGO_WIFI_RSSI_STATE, 242 "[BTCoex], wifi RSSI state " 243 "switch to Low\n"); 244 } else { 245 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM; 246 BTC_PRINT(BTC_MSG_ALGORITHM, 247 ALGO_WIFI_RSSI_STATE, 248 "[BTCoex], wifi RSSI state " 249 "stay at Medium\n"); 250 } 251 } else { 252 if (wifi_rssi < rssi_thresh1) { 253 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM; 254 BTC_PRINT(BTC_MSG_ALGORITHM, 255 ALGO_WIFI_RSSI_STATE, 256 "[BTCoex], wifi RSSI state " 257 "switch to Medium\n"); 258 } else { 259 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH; 260 BTC_PRINT(BTC_MSG_ALGORITHM, 261 ALGO_WIFI_RSSI_STATE, 262 "[BTCoex], wifi RSSI state " 263 "stay at High\n"); 264 } 265 } 266 } 267 268 coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state; 269 270 return wifi_rssi_state; 271 } 272 273 static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist) 274 { 275 u32 reg_hp_txrx, reg_lp_txrx, u32tmp; 276 u32 reg_hp_tx = 0, reg_hp_rx = 0; 277 u32 reg_lp_tx = 0, reg_lp_rx = 0; 278 279 reg_hp_txrx = 0x770; 280 reg_lp_txrx = 0x774; 281 282 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx); 283 reg_hp_tx = u32tmp & MASKLWORD; 284 reg_hp_rx = (u32tmp & MASKHWORD) >> 16; 285 286 u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx); 287 reg_lp_tx = u32tmp & MASKLWORD; 288 reg_lp_rx = (u32tmp & MASKHWORD) >> 16; 289 290 coex_sta->high_priority_tx = reg_hp_tx; 291 coex_sta->high_priority_rx = reg_hp_rx; 292 coex_sta->low_priority_tx = reg_lp_tx; 293 coex_sta->low_priority_rx = reg_lp_rx; 294 295 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, 296 "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n", 297 reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx); 298 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, 299 "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n", 300 reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx); 301 302 /* reset counter */ 303 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); 304 } 305 306 static void btc8723b2ant_query_bt_info(struct btc_coexist *btcoexist) 307 { 308 u8 h2c_parameter[1] = {0}; 309 310 coex_sta->c2h_bt_info_req_sent = true; 311 312 h2c_parameter[0] |= BIT0; /* trigger */ 313 314 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 315 "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n", 316 h2c_parameter[0]); 317 318 btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter); 319 } 320 321 static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist) 322 { 323 static bool pre_wifi_busy; 324 static bool pre_under_4way; 325 static bool pre_bt_hs_on; 326 bool wifi_busy = false, under_4way = false, bt_hs_on = false; 327 bool wifi_connected = false; 328 329 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 330 &wifi_connected); 331 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 332 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 333 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, 334 &under_4way); 335 336 if (wifi_connected) { 337 if (wifi_busy != pre_wifi_busy) { 338 pre_wifi_busy = wifi_busy; 339 return true; 340 } 341 342 if (under_4way != pre_under_4way) { 343 pre_under_4way = under_4way; 344 return true; 345 } 346 347 if (bt_hs_on != pre_bt_hs_on) { 348 pre_bt_hs_on = bt_hs_on; 349 return true; 350 } 351 } 352 353 return false; 354 } 355 356 static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist) 357 { 358 /*struct btc_stack_info *stack_info = &btcoexist->stack_info;*/ 359 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 360 bool bt_hs_on = false; 361 362 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1) /* profile from bt patch */ 363 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 364 365 bt_link_info->bt_link_exist = coex_sta->bt_link_exist; 366 bt_link_info->sco_exist = coex_sta->sco_exist; 367 bt_link_info->a2dp_exist = coex_sta->a2dp_exist; 368 bt_link_info->pan_exist = coex_sta->pan_exist; 369 bt_link_info->hid_exist = coex_sta->hid_exist; 370 371 /* work around for HS mode. */ 372 if (bt_hs_on) { 373 bt_link_info->pan_exist = true; 374 bt_link_info->bt_link_exist = true; 375 } 376 #else /* profile from bt stack */ 377 bt_link_info->bt_link_exist = stack_info->bt_link_exist; 378 bt_link_info->sco_exist = stack_info->sco_exist; 379 bt_link_info->a2dp_exist = stack_info->a2dp_exist; 380 bt_link_info->pan_exist = stack_info->pan_exist; 381 bt_link_info->hid_exist = stack_info->hid_exist; 382 383 /*for win-8 stack HID report error*/ 384 if (!stack_info->hid_exist) 385 stack_info->hid_exist = coex_sta->hid_exist; 386 /*sync BTInfo with BT firmware and stack*/ 387 /* when stack HID report error, here we use the info from bt fw.*/ 388 if (!stack_info->bt_link_exist) 389 stack_info->bt_link_exist = coex_sta->bt_link_exist; 390 #endif 391 /* check if Sco only */ 392 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 393 !bt_link_info->pan_exist && !bt_link_info->hid_exist) 394 bt_link_info->sco_only = true; 395 else 396 bt_link_info->sco_only = false; 397 398 /* check if A2dp only */ 399 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist && 400 !bt_link_info->pan_exist && !bt_link_info->hid_exist) 401 bt_link_info->a2dp_only = true; 402 else 403 bt_link_info->a2dp_only = false; 404 405 /* check if Pan only */ 406 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 407 bt_link_info->pan_exist && !bt_link_info->hid_exist) 408 bt_link_info->pan_only = true; 409 else 410 bt_link_info->pan_only = false; 411 412 /* check if Hid only */ 413 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist && 414 !bt_link_info->pan_exist && bt_link_info->hid_exist) 415 bt_link_info->hid_only = true; 416 else 417 bt_link_info->hid_only = false; 418 } 419 420 static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist) 421 { 422 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 423 bool bt_hs_on = false; 424 u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED; 425 u8 num_of_diff_profile = 0; 426 427 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 428 429 if (!bt_link_info->bt_link_exist) { 430 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 431 "[BTCoex], No BT link exists!!!\n"); 432 return algorithm; 433 } 434 435 if (bt_link_info->sco_exist) 436 num_of_diff_profile++; 437 if (bt_link_info->hid_exist) 438 num_of_diff_profile++; 439 if (bt_link_info->pan_exist) 440 num_of_diff_profile++; 441 if (bt_link_info->a2dp_exist) 442 num_of_diff_profile++; 443 444 if (num_of_diff_profile == 1) { 445 if (bt_link_info->sco_exist) { 446 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 447 "[BTCoex], SCO only\n"); 448 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO; 449 } else { 450 if (bt_link_info->hid_exist) { 451 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 452 "[BTCoex], HID only\n"); 453 algorithm = BT_8723B_2ANT_COEX_ALGO_HID; 454 } else if (bt_link_info->a2dp_exist) { 455 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 456 "[BTCoex], A2DP only\n"); 457 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP; 458 } else if (bt_link_info->pan_exist) { 459 if (bt_hs_on) { 460 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 461 "[BTCoex], PAN(HS) only\n"); 462 algorithm = 463 BT_8723B_2ANT_COEX_ALGO_PANHS; 464 } else { 465 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 466 "[BTCoex], PAN(EDR) only\n"); 467 algorithm = 468 BT_8723B_2ANT_COEX_ALGO_PANEDR; 469 } 470 } 471 } 472 } else if (num_of_diff_profile == 2) { 473 if (bt_link_info->sco_exist) { 474 if (bt_link_info->hid_exist) { 475 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 476 "[BTCoex], SCO + HID\n"); 477 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 478 } else if (bt_link_info->a2dp_exist) { 479 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 480 "[BTCoex], SCO + A2DP ==> SCO\n"); 481 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 482 } else if (bt_link_info->pan_exist) { 483 if (bt_hs_on) { 484 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 485 "[BTCoex], SCO + PAN(HS)\n"); 486 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO; 487 } else { 488 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 489 "[BTCoex], SCO + PAN(EDR)\n"); 490 algorithm = 491 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 492 } 493 } 494 } else { 495 if (bt_link_info->hid_exist && 496 bt_link_info->a2dp_exist) { 497 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 498 "[BTCoex], HID + A2DP\n"); 499 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP; 500 } else if (bt_link_info->hid_exist && 501 bt_link_info->pan_exist) { 502 if (bt_hs_on) { 503 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 504 "[BTCoex], HID + PAN(HS)\n"); 505 algorithm = BT_8723B_2ANT_COEX_ALGO_HID; 506 } else { 507 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 508 "[BTCoex], HID + PAN(EDR)\n"); 509 algorithm = 510 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 511 } 512 } else if (bt_link_info->pan_exist && 513 bt_link_info->a2dp_exist) { 514 if (bt_hs_on) { 515 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 516 "[BTCoex], A2DP + PAN(HS)\n"); 517 algorithm = 518 BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS; 519 } else { 520 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 521 "[BTCoex],A2DP + PAN(EDR)\n"); 522 algorithm = 523 BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP; 524 } 525 } 526 } 527 } else if (num_of_diff_profile == 3) { 528 if (bt_link_info->sco_exist) { 529 if (bt_link_info->hid_exist && 530 bt_link_info->a2dp_exist) { 531 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 532 "[BTCoex], SCO + HID + A2DP" 533 " ==> HID\n"); 534 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 535 } else if (bt_link_info->hid_exist && 536 bt_link_info->pan_exist) { 537 if (bt_hs_on) { 538 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 539 "[BTCoex], SCO + HID + " 540 "PAN(HS)\n"); 541 algorithm = 542 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 543 } else { 544 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 545 "[BTCoex], SCO + HID + " 546 "PAN(EDR)\n"); 547 algorithm = 548 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 549 } 550 } else if (bt_link_info->pan_exist && 551 bt_link_info->a2dp_exist) { 552 if (bt_hs_on) { 553 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 554 "[BTCoex], SCO + A2DP + " 555 "PAN(HS)\n"); 556 algorithm = 557 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 558 } else { 559 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 560 "[BTCoex], SCO + A2DP + " 561 "PAN(EDR) ==> HID\n"); 562 algorithm = 563 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 564 } 565 } 566 } else { 567 if (bt_link_info->hid_exist && 568 bt_link_info->pan_exist && 569 bt_link_info->a2dp_exist) { 570 if (bt_hs_on) { 571 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 572 "[BTCoex], HID + A2DP + " 573 "PAN(HS)\n"); 574 algorithm = 575 BT_8723B_2ANT_COEX_ALGO_HID_A2DP; 576 } else { 577 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 578 "[BTCoex], HID + A2DP + " 579 "PAN(EDR)\n"); 580 algorithm = 581 BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR; 582 } 583 } 584 } 585 } else if (num_of_diff_profile >= 3) { 586 if (bt_link_info->sco_exist) { 587 if (bt_link_info->hid_exist && 588 bt_link_info->pan_exist && 589 bt_link_info->a2dp_exist) { 590 if (bt_hs_on) { 591 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 592 "[BTCoex], Error!!! SCO + HID" 593 " + A2DP + PAN(HS)\n"); 594 } else { 595 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 596 "[BTCoex], SCO + HID + A2DP +" 597 " PAN(EDR)==>PAN(EDR)+HID\n"); 598 algorithm = 599 BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 600 } 601 } 602 } 603 } 604 return algorithm; 605 } 606 607 static bool btc8723b_need_dec_pwr(struct btc_coexist *btcoexist) 608 { 609 bool ret = false; 610 bool bt_hs_on = false, wifi_connected = false; 611 s32 bt_hs_rssi = 0; 612 u8 bt_rssi_state; 613 614 if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on)) 615 return false; 616 if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 617 &wifi_connected)) 618 return false; 619 if (!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi)) 620 return false; 621 622 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 623 624 if (wifi_connected) { 625 if (bt_hs_on) { 626 if (bt_hs_rssi > 37) { 627 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 628 "[BTCoex], Need to decrease bt " 629 "power for HS mode!!\n"); 630 ret = true; 631 } 632 } else { 633 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 634 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 635 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 636 "[BTCoex], Need to decrease bt " 637 "power for Wifi is connected!!\n"); 638 ret = true; 639 } 640 } 641 } 642 643 return ret; 644 } 645 646 static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist, 647 u8 dac_swing_lvl) 648 { 649 u8 h2c_parameter[1] = {0}; 650 651 /* There are several type of dacswing 652 * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 653 */ 654 h2c_parameter[0] = dac_swing_lvl; 655 656 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 657 "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl); 658 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 659 "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]); 660 661 btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter); 662 } 663 664 static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist, 665 bool dec_bt_pwr) 666 { 667 u8 h2c_parameter[1] = {0}; 668 669 h2c_parameter[0] = 0; 670 671 if (dec_bt_pwr) 672 h2c_parameter[0] |= BIT1; 673 674 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 675 "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n", 676 (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]); 677 678 btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter); 679 } 680 681 static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist, 682 bool force_exec, bool dec_bt_pwr) 683 { 684 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 685 "[BTCoex], %s Dec BT power = %s\n", 686 (force_exec ? "force to" : ""), (dec_bt_pwr ? "ON" : "OFF")); 687 coex_dm->cur_dec_bt_pwr = dec_bt_pwr; 688 689 if (!force_exec) { 690 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 691 "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n", 692 coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr); 693 694 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr) 695 return; 696 } 697 btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr); 698 699 coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr; 700 } 701 702 static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist, 703 bool force_exec, u8 fw_dac_swing_lvl) 704 { 705 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 706 "[BTCoex], %s set FW Dac Swing level = %d\n", 707 (force_exec ? "force to" : ""), fw_dac_swing_lvl); 708 coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl; 709 710 if (!force_exec) { 711 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 712 "[BTCoex], preFwDacSwingLvl=%d, " 713 "curFwDacSwingLvl=%d\n", 714 coex_dm->pre_fw_dac_swing_lvl, 715 coex_dm->cur_fw_dac_swing_lvl); 716 717 if (coex_dm->pre_fw_dac_swing_lvl == 718 coex_dm->cur_fw_dac_swing_lvl) 719 return; 720 } 721 722 btc8723b2ant_set_fw_dac_swing_level(btcoexist, 723 coex_dm->cur_fw_dac_swing_lvl); 724 coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl; 725 } 726 727 static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist, 728 bool rx_rf_shrink_on) 729 { 730 if (rx_rf_shrink_on) { 731 /* Shrink RF Rx LPF corner */ 732 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 733 "[BTCoex], Shrink RF Rx LPF corner!!\n"); 734 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e, 735 0xfffff, 0xffffc); 736 } else { 737 /* Resume RF Rx LPF corner */ 738 /* After initialized, we can use coex_dm->btRf0x1eBackup */ 739 if (btcoexist->initilized) { 740 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 741 "[BTCoex], Resume RF Rx LPF corner!!\n"); 742 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e, 743 0xfffff, 744 coex_dm->bt_rf0x1e_backup); 745 } 746 } 747 } 748 749 static void btc8723b2ant_rf_shrink(struct btc_coexist *btcoexist, 750 bool force_exec, bool rx_rf_shrink_on) 751 { 752 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, 753 "[BTCoex], %s turn Rx RF Shrink = %s\n", 754 (force_exec ? "force to" : ""), (rx_rf_shrink_on ? 755 "ON" : "OFF")); 756 coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on; 757 758 if (!force_exec) { 759 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 760 "[BTCoex], bPreRfRxLpfShrink=%d, " 761 "bCurRfRxLpfShrink=%d\n", 762 coex_dm->pre_rf_rx_lpf_shrink, 763 coex_dm->cur_rf_rx_lpf_shrink); 764 765 if (coex_dm->pre_rf_rx_lpf_shrink == 766 coex_dm->cur_rf_rx_lpf_shrink) 767 return; 768 } 769 btc8723b2ant_set_sw_rf_rx_lpf_corner(btcoexist, 770 coex_dm->cur_rf_rx_lpf_shrink); 771 772 coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink; 773 } 774 775 static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist, 776 bool low_penalty_ra) 777 { 778 u8 h2c_parameter[6] = {0}; 779 780 h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/ 781 782 if (low_penalty_ra) { 783 h2c_parameter[1] |= BIT0; 784 /*normal rate except MCS7/6/5, OFDM54/48/36*/ 785 h2c_parameter[2] = 0x00; 786 h2c_parameter[3] = 0xf7; /*MCS7 or OFDM54*/ 787 h2c_parameter[4] = 0xf8; /*MCS6 or OFDM48*/ 788 h2c_parameter[5] = 0xf9; /*MCS5 or OFDM36*/ 789 } 790 791 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 792 "[BTCoex], set WiFi Low-Penalty Retry: %s", 793 (low_penalty_ra ? "ON!!" : "OFF!!")); 794 795 btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter); 796 } 797 798 static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist, 799 bool force_exec, bool low_penalty_ra) 800 { 801 /*return; */ 802 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, 803 "[BTCoex], %s turn LowPenaltyRA = %s\n", 804 (force_exec ? "force to" : ""), (low_penalty_ra ? 805 "ON" : "OFF")); 806 coex_dm->cur_low_penalty_ra = low_penalty_ra; 807 808 if (!force_exec) { 809 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 810 "[BTCoex], bPreLowPenaltyRa=%d, " 811 "bCurLowPenaltyRa=%d\n", 812 coex_dm->pre_low_penalty_ra, 813 coex_dm->cur_low_penalty_ra); 814 815 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra) 816 return; 817 } 818 btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra); 819 820 coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra; 821 } 822 823 static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist, 824 u32 level) 825 { 826 u8 val = (u8) level; 827 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 828 "[BTCoex], Write SwDacSwing = 0x%x\n", level); 829 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val); 830 } 831 832 static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex, 833 bool sw_dac_swing_on, 834 u32 sw_dac_swing_lvl) 835 { 836 if (sw_dac_swing_on) 837 btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl); 838 else 839 btc8723b2ant_set_dac_swing_reg(btcoex, 0x18); 840 } 841 842 static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist, 843 bool force_exec, bool dac_swing_on, 844 u32 dac_swing_lvl) 845 { 846 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, 847 "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n", 848 (force_exec ? "force to" : ""), 849 (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl); 850 coex_dm->cur_dac_swing_on = dac_swing_on; 851 coex_dm->cur_dac_swing_lvl = dac_swing_lvl; 852 853 if (!force_exec) { 854 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 855 "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x," 856 " bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n", 857 coex_dm->pre_dac_swing_on, coex_dm->pre_dac_swing_lvl, 858 coex_dm->cur_dac_swing_on, 859 coex_dm->cur_dac_swing_lvl); 860 861 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) && 862 (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl)) 863 return; 864 } 865 mdelay(30); 866 btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on, 867 dac_swing_lvl); 868 869 coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on; 870 coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl; 871 } 872 873 static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist, 874 bool agc_table_en) 875 { 876 u8 rssi_adjust_val = 0; 877 878 /* BB AGC Gain Table */ 879 if (agc_table_en) { 880 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 881 "[BTCoex], BB Agc Table On!\n"); 882 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6e1A0001); 883 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6d1B0001); 884 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6c1C0001); 885 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6b1D0001); 886 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6a1E0001); 887 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x691F0001); 888 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x68200001); 889 } else { 890 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 891 "[BTCoex], BB Agc Table Off!\n"); 892 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001); 893 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001); 894 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001); 895 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa71D0001); 896 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa61E0001); 897 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa51F0001); 898 btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa4200001); 899 } 900 901 /* RF Gain */ 902 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000); 903 if (agc_table_en) { 904 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 905 "[BTCoex], Agc Table On!\n"); 906 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 907 0xfffff, 0x38fff); 908 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 909 0xfffff, 0x38ffe); 910 } else { 911 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 912 "[BTCoex], Agc Table Off!\n"); 913 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 914 0xfffff, 0x380c3); 915 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 916 0xfffff, 0x28ce6); 917 } 918 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0); 919 920 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1); 921 922 if (agc_table_en) { 923 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 924 "[BTCoex], Agc Table On!\n"); 925 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 926 0xfffff, 0x38fff); 927 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 928 0xfffff, 0x38ffe); 929 } else { 930 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 931 "[BTCoex], Agc Table Off!\n"); 932 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 933 0xfffff, 0x380c3); 934 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40, 935 0xfffff, 0x28ce6); 936 } 937 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x0); 938 939 /* set rssiAdjustVal for wifi module. */ 940 if (agc_table_en) 941 rssi_adjust_val = 8; 942 btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, 943 &rssi_adjust_val); 944 } 945 946 static void btc8723b2ant_agc_table(struct btc_coexist *btcoexist, 947 bool force_exec, bool agc_table_en) 948 { 949 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, 950 "[BTCoex], %s %s Agc Table\n", 951 (force_exec ? "force to" : ""), 952 (agc_table_en ? "Enable" : "Disable")); 953 coex_dm->cur_agc_table_en = agc_table_en; 954 955 if (!force_exec) { 956 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 957 "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n", 958 coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en); 959 960 if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en) 961 return; 962 } 963 btc8723b2ant_set_agc_table(btcoexist, agc_table_en); 964 965 coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en; 966 } 967 968 static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist, 969 u32 val0x6c0, u32 val0x6c4, 970 u32 val0x6c8, u8 val0x6cc) 971 { 972 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 973 "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0); 974 btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0); 975 976 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 977 "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4); 978 btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4); 979 980 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 981 "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8); 982 btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8); 983 984 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, 985 "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc); 986 btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc); 987 } 988 989 static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist, 990 bool force_exec, u32 val0x6c0, 991 u32 val0x6c4, u32 val0x6c8, 992 u8 val0x6cc) 993 { 994 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, 995 "[BTCoex], %s write Coex Table 0x6c0=0x%x," 996 " 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n", 997 (force_exec ? "force to" : ""), val0x6c0, 998 val0x6c4, val0x6c8, val0x6cc); 999 coex_dm->cur_val0x6c0 = val0x6c0; 1000 coex_dm->cur_val0x6c4 = val0x6c4; 1001 coex_dm->cur_val0x6c8 = val0x6c8; 1002 coex_dm->cur_val0x6cc = val0x6cc; 1003 1004 if (!force_exec) { 1005 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 1006 "[BTCoex], preVal0x6c0=0x%x, " 1007 "preVal0x6c4=0x%x, preVal0x6c8=0x%x, " 1008 "preVal0x6cc=0x%x !!\n", 1009 coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4, 1010 coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc); 1011 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, 1012 "[BTCoex], curVal0x6c0=0x%x, " 1013 "curVal0x6c4=0x%x, curVal0x6c8=0x%x, " 1014 "curVal0x6cc=0x%x !!\n", 1015 coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4, 1016 coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc); 1017 1018 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) && 1019 (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) && 1020 (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) && 1021 (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc)) 1022 return; 1023 } 1024 btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, 1025 val0x6c8, val0x6cc); 1026 1027 coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0; 1028 coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4; 1029 coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8; 1030 coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc; 1031 } 1032 1033 static void btc8723b_coex_tbl_type(struct btc_coexist *btcoexist, 1034 bool force_exec, u8 type) 1035 { 1036 switch (type) { 1037 case 0: 1038 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555, 1039 0x55555555, 0xffff, 0x3); 1040 break; 1041 case 1: 1042 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555, 1043 0x5afa5afa, 0xffff, 0x3); 1044 break; 1045 case 2: 1046 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a, 1047 0x5a5a5a5a, 0xffff, 0x3); 1048 break; 1049 case 3: 1050 btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa, 1051 0xaaaaaaaa, 0xffff, 0x3); 1052 break; 1053 case 4: 1054 btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff, 1055 0xffffffff, 0xffff, 0x3); 1056 break; 1057 case 5: 1058 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff, 1059 0x5fff5fff, 0xffff, 0x3); 1060 break; 1061 case 6: 1062 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1063 0x5a5a5a5a, 0xffff, 0x3); 1064 break; 1065 case 7: 1066 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1067 0x5afa5afa, 0xffff, 0x3); 1068 break; 1069 case 8: 1070 btc8723b2ant_coex_table(btcoexist, force_exec, 0x5aea5aea, 1071 0x5aea5aea, 0xffff, 0x3); 1072 break; 1073 case 9: 1074 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1075 0x5aea5aea, 0xffff, 0x3); 1076 break; 1077 case 10: 1078 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1079 0x5aff5aff, 0xffff, 0x3); 1080 break; 1081 case 11: 1082 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1083 0x5a5f5a5f, 0xffff, 0x3); 1084 break; 1085 case 12: 1086 btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff, 1087 0x5f5f5f5f, 0xffff, 0x3); 1088 break; 1089 default: 1090 break; 1091 } 1092 } 1093 1094 static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist, 1095 bool enable) 1096 { 1097 u8 h2c_parameter[1] = {0}; 1098 1099 if (enable) 1100 h2c_parameter[0] |= BIT0;/* function enable*/ 1101 1102 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 1103 "[BTCoex], set FW for BT Ignore Wlan_Act, " 1104 "FW write 0x63=0x%x\n", h2c_parameter[0]); 1105 1106 btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter); 1107 } 1108 1109 static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist, 1110 bool force_exec, bool enable) 1111 { 1112 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 1113 "[BTCoex], %s turn Ignore WlanAct %s\n", 1114 (force_exec ? "force to" : ""), (enable ? "ON" : "OFF")); 1115 coex_dm->cur_ignore_wlan_act = enable; 1116 1117 if (!force_exec) { 1118 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 1119 "[BTCoex], bPreIgnoreWlanAct = %d, " 1120 "bCurIgnoreWlanAct = %d!!\n", 1121 coex_dm->pre_ignore_wlan_act, 1122 coex_dm->cur_ignore_wlan_act); 1123 1124 if (coex_dm->pre_ignore_wlan_act == 1125 coex_dm->cur_ignore_wlan_act) 1126 return; 1127 } 1128 btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable); 1129 1130 coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act; 1131 } 1132 1133 static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1, 1134 u8 byte2, u8 byte3, u8 byte4, u8 byte5) 1135 { 1136 u8 h2c_parameter[5]; 1137 1138 h2c_parameter[0] = byte1; 1139 h2c_parameter[1] = byte2; 1140 h2c_parameter[2] = byte3; 1141 h2c_parameter[3] = byte4; 1142 h2c_parameter[4] = byte5; 1143 1144 coex_dm->ps_tdma_para[0] = byte1; 1145 coex_dm->ps_tdma_para[1] = byte2; 1146 coex_dm->ps_tdma_para[2] = byte3; 1147 coex_dm->ps_tdma_para[3] = byte4; 1148 coex_dm->ps_tdma_para[4] = byte5; 1149 1150 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 1151 "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n", 1152 h2c_parameter[0], 1153 h2c_parameter[1] << 24 | h2c_parameter[2] << 16 | 1154 h2c_parameter[3] << 8 | h2c_parameter[4]); 1155 1156 btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter); 1157 } 1158 1159 static void btc8723b2ant_sw_mechanism1(struct btc_coexist *btcoexist, 1160 bool shrink_rx_lpf, bool low_penalty_ra, 1161 bool limited_dig, bool bt_lna_constrain) 1162 { 1163 btc8723b2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf); 1164 btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra); 1165 } 1166 1167 static void btc8723b2ant_sw_mechanism2(struct btc_coexist *btcoexist, 1168 bool agc_table_shift, bool adc_backoff, 1169 bool sw_dac_swing, u32 dac_swing_lvl) 1170 { 1171 btc8723b2ant_agc_table(btcoexist, NORMAL_EXEC, agc_table_shift); 1172 btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing, 1173 dac_swing_lvl); 1174 } 1175 1176 static void btc8723b2ant_set_ant_path(struct btc_coexist *btcoexist, 1177 u8 antpos_type, bool init_hwcfg, 1178 bool wifi_off) 1179 { 1180 struct btc_board_info *board_info = &btcoexist->board_info; 1181 u32 fw_ver = 0, u32tmp = 0; 1182 bool pg_ext_switch = false; 1183 bool use_ext_switch = false; 1184 u8 h2c_parameter[2] = {0}; 1185 1186 btcoexist->btc_get(btcoexist, BTC_GET_BL_EXT_SWITCH, &pg_ext_switch); 1187 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 1188 1189 if ((fw_ver < 0xc0000) || pg_ext_switch) 1190 use_ext_switch = true; 1191 1192 if (init_hwcfg) { 1193 /* 0x4c[23] = 0, 0x4c[24] = 1 Antenna control by WL/BT */ 1194 u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c); 1195 u32tmp &= ~BIT23; 1196 u32tmp |= BIT24; 1197 btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp); 1198 1199 btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff); 1200 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3); 1201 btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77); 1202 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1); 1203 1204 /* Force GNT_BT to low */ 1205 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0); 1206 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); 1207 1208 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) { 1209 /* tell firmware "no antenna inverse" */ 1210 h2c_parameter[0] = 0; 1211 h2c_parameter[1] = 1; /* ext switch type */ 1212 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 1213 h2c_parameter); 1214 } else { 1215 /* tell firmware "antenna inverse" */ 1216 h2c_parameter[0] = 1; 1217 h2c_parameter[1] = 1; /* ext switch type */ 1218 btcoexist->btc_fill_h2c(btcoexist, 0x65, 2, 1219 h2c_parameter); 1220 } 1221 } 1222 1223 /* ext switch setting */ 1224 if (use_ext_switch) { 1225 /* fixed internal switch S1->WiFi, S0->BT */ 1226 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); 1227 switch (antpos_type) { 1228 case BTC_ANT_WIFI_AT_MAIN: 1229 /* ext switch main at wifi */ 1230 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c, 1231 0x3, 0x1); 1232 break; 1233 case BTC_ANT_WIFI_AT_AUX: 1234 /* ext switch aux at wifi */ 1235 btcoexist->btc_write_1byte_bitmask(btcoexist, 1236 0x92c, 0x3, 0x2); 1237 break; 1238 } 1239 } else { /* internal switch */ 1240 /* fixed ext switch */ 1241 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c, 0x3, 0x1); 1242 switch (antpos_type) { 1243 case BTC_ANT_WIFI_AT_MAIN: 1244 /* fixed internal switch S1->WiFi, S0->BT */ 1245 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0); 1246 break; 1247 case BTC_ANT_WIFI_AT_AUX: 1248 /* fixed internal switch S0->WiFi, S1->BT */ 1249 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280); 1250 break; 1251 } 1252 } 1253 } 1254 1255 static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec, 1256 bool turn_on, u8 type) 1257 { 1258 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 1259 "[BTCoex], %s turn %s PS TDMA, type=%d\n", 1260 (force_exec ? "force to" : ""), 1261 (turn_on ? "ON" : "OFF"), type); 1262 coex_dm->cur_ps_tdma_on = turn_on; 1263 coex_dm->cur_ps_tdma = type; 1264 1265 if (!force_exec) { 1266 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 1267 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n", 1268 coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on); 1269 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 1270 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n", 1271 coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma); 1272 1273 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) && 1274 (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma)) 1275 return; 1276 } 1277 if (turn_on) { 1278 switch (type) { 1279 case 1: 1280 default: 1281 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a, 1282 0x1a, 0xe1, 0x90); 1283 break; 1284 case 2: 1285 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12, 1286 0x12, 0xe1, 0x90); 1287 break; 1288 case 3: 1289 /* This call breaks BT when wireless is active - 1290 * comment it out for now until a better fix is found: 1291 * btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c, 1292 * 0x3, 0xf1, 0x90); 1293 */ 1294 break; 1295 case 4: 1296 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10, 1297 0x03, 0xf1, 0x90); 1298 break; 1299 case 5: 1300 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a, 1301 0x1a, 0x60, 0x90); 1302 break; 1303 case 6: 1304 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12, 1305 0x12, 0x60, 0x90); 1306 break; 1307 case 7: 1308 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c, 1309 0x3, 0x70, 0x90); 1310 break; 1311 case 8: 1312 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10, 1313 0x3, 0x70, 0x90); 1314 break; 1315 case 9: 1316 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a, 1317 0x1a, 0xe1, 0x90); 1318 break; 1319 case 10: 1320 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12, 1321 0x12, 0xe1, 0x90); 1322 break; 1323 case 11: 1324 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa, 1325 0xa, 0xe1, 0x90); 1326 break; 1327 case 12: 1328 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 1329 0x5, 0xe1, 0x90); 1330 break; 1331 case 13: 1332 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a, 1333 0x1a, 0x60, 0x90); 1334 break; 1335 case 14: 1336 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12, 1337 0x12, 0x60, 0x90); 1338 break; 1339 case 15: 1340 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa, 1341 0xa, 0x60, 0x90); 1342 break; 1343 case 16: 1344 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 1345 0x5, 0x60, 0x90); 1346 break; 1347 case 17: 1348 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f, 1349 0x2f, 0x60, 0x90); 1350 break; 1351 case 18: 1352 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5, 1353 0x5, 0xe1, 0x90); 1354 break; 1355 case 19: 1356 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25, 1357 0x25, 0xe1, 0x90); 1358 break; 1359 case 20: 1360 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25, 1361 0x25, 0x60, 0x90); 1362 break; 1363 case 21: 1364 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15, 1365 0x03, 0x70, 0x90); 1366 break; 1367 case 71: 1368 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a, 1369 0x1a, 0xe1, 0x90); 1370 break; 1371 } 1372 } else { 1373 /* disable PS tdma */ 1374 switch (type) { 1375 case 0: 1376 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0, 1377 0x40, 0x0); 1378 break; 1379 case 1: 1380 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0, 1381 0x48, 0x0); 1382 break; 1383 default: 1384 btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0, 1385 0x40, 0x0); 1386 break; 1387 } 1388 } 1389 1390 /* update pre state */ 1391 coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on; 1392 coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma; 1393 } 1394 1395 static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist) 1396 { 1397 /* fw all off */ 1398 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 1399 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 1400 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 1401 1402 /* sw all off */ 1403 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false); 1404 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18); 1405 1406 /* hw all off */ 1407 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 1408 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 1409 } 1410 1411 static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist) 1412 { 1413 /* force to reset coex mechanism*/ 1414 1415 btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1); 1416 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6); 1417 btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false); 1418 1419 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false); 1420 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18); 1421 } 1422 1423 static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist) 1424 { 1425 bool wifi_connected = false; 1426 bool low_pwr_disable = true; 1427 1428 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER, 1429 &low_pwr_disable); 1430 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 1431 &wifi_connected); 1432 1433 if (wifi_connected) { 1434 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 1435 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 1436 } else { 1437 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 1438 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 1439 } 1440 btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6); 1441 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 1442 1443 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false); 1444 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18); 1445 1446 coex_dm->need_recover_0x948 = true; 1447 coex_dm->backup_0x948 = btcoexist->btc_read_2byte(btcoexist, 0x948); 1448 1449 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_AUX, 1450 false, false); 1451 } 1452 1453 static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist) 1454 { 1455 bool common = false, wifi_connected = false; 1456 bool wifi_busy = false; 1457 bool bt_hs_on = false, low_pwr_disable = false; 1458 1459 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 1460 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 1461 &wifi_connected); 1462 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 1463 1464 if (!wifi_connected) { 1465 low_pwr_disable = false; 1466 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER, 1467 &low_pwr_disable); 1468 1469 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 1470 "[BTCoex], Wifi non-connected idle!!\n"); 1471 1472 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 1473 0x0); 1474 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 1475 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 1476 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 1477 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 1478 1479 btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, 1480 false); 1481 btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 1482 0x18); 1483 1484 common = true; 1485 } else { 1486 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == 1487 coex_dm->bt_status) { 1488 low_pwr_disable = false; 1489 btcoexist->btc_set(btcoexist, 1490 BTC_SET_ACT_DISABLE_LOW_POWER, 1491 &low_pwr_disable); 1492 1493 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 1494 "[BTCoex], Wifi connected + " 1495 "BT non connected-idle!!\n"); 1496 1497 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 1498 0xfffff, 0x0); 1499 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 1500 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 1501 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 1502 0xb); 1503 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 1504 false); 1505 1506 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 1507 false, false); 1508 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 1509 false, 0x18); 1510 1511 common = true; 1512 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == 1513 coex_dm->bt_status) { 1514 low_pwr_disable = true; 1515 btcoexist->btc_set(btcoexist, 1516 BTC_SET_ACT_DISABLE_LOW_POWER, 1517 &low_pwr_disable); 1518 1519 if (bt_hs_on) 1520 return false; 1521 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 1522 "[BTCoex], Wifi connected + " 1523 "BT connected-idle!!\n"); 1524 1525 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 1526 0xfffff, 0x0); 1527 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 1528 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 1529 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 1530 0xb); 1531 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 1532 false); 1533 1534 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 1535 false, false); 1536 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 1537 false, 0x18); 1538 1539 common = true; 1540 } else { 1541 low_pwr_disable = true; 1542 btcoexist->btc_set(btcoexist, 1543 BTC_SET_ACT_DISABLE_LOW_POWER, 1544 &low_pwr_disable); 1545 1546 if (wifi_busy) { 1547 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 1548 "[BTCoex], Wifi Connected-Busy + " 1549 "BT Busy!!\n"); 1550 common = false; 1551 } else { 1552 if (bt_hs_on) 1553 return false; 1554 1555 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 1556 "[BTCoex], Wifi Connected-Idle + " 1557 "BT Busy!!\n"); 1558 1559 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 1560 0x1, 0xfffff, 0x0); 1561 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 1562 7); 1563 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1564 true, 21); 1565 btc8723b2ant_fw_dac_swing_lvl(btcoexist, 1566 NORMAL_EXEC, 1567 0xb); 1568 if (btc8723b_need_dec_pwr(btcoexist)) 1569 btc8723b2ant_dec_bt_pwr(btcoexist, 1570 NORMAL_EXEC, 1571 true); 1572 else 1573 btc8723b2ant_dec_bt_pwr(btcoexist, 1574 NORMAL_EXEC, 1575 false); 1576 btc8723b2ant_sw_mechanism1(btcoexist, false, 1577 false, false, 1578 false); 1579 btc8723b2ant_sw_mechanism2(btcoexist, false, 1580 false, false, 1581 0x18); 1582 common = true; 1583 } 1584 } 1585 } 1586 1587 return common; 1588 } 1589 1590 static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause, 1591 s32 result) 1592 { 1593 /* Set PS TDMA for max interval == 1 */ 1594 if (tx_pause) { 1595 BTC_PRINT(BTC_MSG_ALGORITHM, 1596 ALGO_TRACE_FW_DETAIL, 1597 "[BTCoex], TxPause = 1\n"); 1598 1599 if (coex_dm->cur_ps_tdma == 71) { 1600 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1601 true, 5); 1602 coex_dm->tdma_adj_type = 5; 1603 } else if (coex_dm->cur_ps_tdma == 1) { 1604 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1605 true, 5); 1606 coex_dm->tdma_adj_type = 5; 1607 } else if (coex_dm->cur_ps_tdma == 2) { 1608 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1609 true, 6); 1610 coex_dm->tdma_adj_type = 6; 1611 } else if (coex_dm->cur_ps_tdma == 3) { 1612 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1613 true, 7); 1614 coex_dm->tdma_adj_type = 7; 1615 } else if (coex_dm->cur_ps_tdma == 4) { 1616 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1617 true, 8); 1618 coex_dm->tdma_adj_type = 8; 1619 } 1620 1621 if (coex_dm->cur_ps_tdma == 9) { 1622 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1623 true, 13); 1624 coex_dm->tdma_adj_type = 13; 1625 } else if (coex_dm->cur_ps_tdma == 10) { 1626 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1627 true, 14); 1628 coex_dm->tdma_adj_type = 14; 1629 } else if (coex_dm->cur_ps_tdma == 11) { 1630 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1631 true, 15); 1632 coex_dm->tdma_adj_type = 15; 1633 } else if (coex_dm->cur_ps_tdma == 12) { 1634 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1635 true, 16); 1636 coex_dm->tdma_adj_type = 16; 1637 } 1638 1639 if (result == -1) { 1640 if (coex_dm->cur_ps_tdma == 5) { 1641 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1642 true, 6); 1643 coex_dm->tdma_adj_type = 6; 1644 } else if (coex_dm->cur_ps_tdma == 6) { 1645 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1646 true, 7); 1647 coex_dm->tdma_adj_type = 7; 1648 } else if (coex_dm->cur_ps_tdma == 7) { 1649 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1650 true, 8); 1651 coex_dm->tdma_adj_type = 8; 1652 } else if (coex_dm->cur_ps_tdma == 13) { 1653 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1654 true, 14); 1655 coex_dm->tdma_adj_type = 14; 1656 } else if (coex_dm->cur_ps_tdma == 14) { 1657 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1658 true, 15); 1659 coex_dm->tdma_adj_type = 15; 1660 } else if (coex_dm->cur_ps_tdma == 15) { 1661 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1662 true, 16); 1663 coex_dm->tdma_adj_type = 16; 1664 } 1665 } else if (result == 1) { 1666 if (coex_dm->cur_ps_tdma == 8) { 1667 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1668 true, 7); 1669 coex_dm->tdma_adj_type = 7; 1670 } else if (coex_dm->cur_ps_tdma == 7) { 1671 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1672 true, 6); 1673 coex_dm->tdma_adj_type = 6; 1674 } else if (coex_dm->cur_ps_tdma == 6) { 1675 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1676 true, 5); 1677 coex_dm->tdma_adj_type = 5; 1678 } else if (coex_dm->cur_ps_tdma == 16) { 1679 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1680 true, 15); 1681 coex_dm->tdma_adj_type = 15; 1682 } else if (coex_dm->cur_ps_tdma == 15) { 1683 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1684 true, 14); 1685 coex_dm->tdma_adj_type = 14; 1686 } else if (coex_dm->cur_ps_tdma == 14) { 1687 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1688 true, 13); 1689 coex_dm->tdma_adj_type = 13; 1690 } 1691 } 1692 } else { 1693 BTC_PRINT(BTC_MSG_ALGORITHM, 1694 ALGO_TRACE_FW_DETAIL, 1695 "[BTCoex], TxPause = 0\n"); 1696 if (coex_dm->cur_ps_tdma == 5) { 1697 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71); 1698 coex_dm->tdma_adj_type = 71; 1699 } else if (coex_dm->cur_ps_tdma == 6) { 1700 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2); 1701 coex_dm->tdma_adj_type = 2; 1702 } else if (coex_dm->cur_ps_tdma == 7) { 1703 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 1704 coex_dm->tdma_adj_type = 3; 1705 } else if (coex_dm->cur_ps_tdma == 8) { 1706 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4); 1707 coex_dm->tdma_adj_type = 4; 1708 } 1709 1710 if (coex_dm->cur_ps_tdma == 13) { 1711 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9); 1712 coex_dm->tdma_adj_type = 9; 1713 } else if (coex_dm->cur_ps_tdma == 14) { 1714 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10); 1715 coex_dm->tdma_adj_type = 10; 1716 } else if (coex_dm->cur_ps_tdma == 15) { 1717 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 1718 coex_dm->tdma_adj_type = 11; 1719 } else if (coex_dm->cur_ps_tdma == 16) { 1720 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12); 1721 coex_dm->tdma_adj_type = 12; 1722 } 1723 1724 if (result == -1) { 1725 if (coex_dm->cur_ps_tdma == 71) { 1726 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1727 true, 1); 1728 coex_dm->tdma_adj_type = 1; 1729 } else if (coex_dm->cur_ps_tdma == 1) { 1730 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1731 true, 2); 1732 coex_dm->tdma_adj_type = 2; 1733 } else if (coex_dm->cur_ps_tdma == 2) { 1734 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1735 true, 3); 1736 coex_dm->tdma_adj_type = 3; 1737 } else if (coex_dm->cur_ps_tdma == 3) { 1738 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1739 true, 4); 1740 coex_dm->tdma_adj_type = 4; 1741 } else if (coex_dm->cur_ps_tdma == 9) { 1742 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1743 true, 10); 1744 coex_dm->tdma_adj_type = 10; 1745 } else if (coex_dm->cur_ps_tdma == 10) { 1746 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1747 true, 11); 1748 coex_dm->tdma_adj_type = 11; 1749 } else if (coex_dm->cur_ps_tdma == 11) { 1750 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1751 true, 12); 1752 coex_dm->tdma_adj_type = 12; 1753 } 1754 } else if (result == 1) { 1755 if (coex_dm->cur_ps_tdma == 4) { 1756 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1757 true, 3); 1758 coex_dm->tdma_adj_type = 3; 1759 } else if (coex_dm->cur_ps_tdma == 3) { 1760 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1761 true, 2); 1762 coex_dm->tdma_adj_type = 2; 1763 } else if (coex_dm->cur_ps_tdma == 2) { 1764 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1765 true, 1); 1766 coex_dm->tdma_adj_type = 1; 1767 } else if (coex_dm->cur_ps_tdma == 1) { 1768 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1769 true, 71); 1770 coex_dm->tdma_adj_type = 71; 1771 } else if (coex_dm->cur_ps_tdma == 12) { 1772 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1773 true, 11); 1774 coex_dm->tdma_adj_type = 11; 1775 } else if (coex_dm->cur_ps_tdma == 11) { 1776 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1777 true, 10); 1778 coex_dm->tdma_adj_type = 10; 1779 } else if (coex_dm->cur_ps_tdma == 10) { 1780 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1781 true, 9); 1782 coex_dm->tdma_adj_type = 9; 1783 } 1784 } 1785 } 1786 } 1787 1788 static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause, 1789 s32 result) 1790 { 1791 /* Set PS TDMA for max interval == 2 */ 1792 if (tx_pause) { 1793 BTC_PRINT(BTC_MSG_ALGORITHM, 1794 ALGO_TRACE_FW_DETAIL, 1795 "[BTCoex], TxPause = 1\n"); 1796 if (coex_dm->cur_ps_tdma == 1) { 1797 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6); 1798 coex_dm->tdma_adj_type = 6; 1799 } else if (coex_dm->cur_ps_tdma == 2) { 1800 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6); 1801 coex_dm->tdma_adj_type = 6; 1802 } else if (coex_dm->cur_ps_tdma == 3) { 1803 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7); 1804 coex_dm->tdma_adj_type = 7; 1805 } else if (coex_dm->cur_ps_tdma == 4) { 1806 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8); 1807 coex_dm->tdma_adj_type = 8; 1808 } 1809 if (coex_dm->cur_ps_tdma == 9) { 1810 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1811 coex_dm->tdma_adj_type = 14; 1812 } else if (coex_dm->cur_ps_tdma == 10) { 1813 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14); 1814 coex_dm->tdma_adj_type = 14; 1815 } else if (coex_dm->cur_ps_tdma == 11) { 1816 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15); 1817 coex_dm->tdma_adj_type = 15; 1818 } else if (coex_dm->cur_ps_tdma == 12) { 1819 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16); 1820 coex_dm->tdma_adj_type = 16; 1821 } 1822 if (result == -1) { 1823 if (coex_dm->cur_ps_tdma == 5) { 1824 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1825 true, 6); 1826 coex_dm->tdma_adj_type = 6; 1827 } else if (coex_dm->cur_ps_tdma == 6) { 1828 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1829 true, 7); 1830 coex_dm->tdma_adj_type = 7; 1831 } else if (coex_dm->cur_ps_tdma == 7) { 1832 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1833 true, 8); 1834 coex_dm->tdma_adj_type = 8; 1835 } else if (coex_dm->cur_ps_tdma == 13) { 1836 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1837 true, 14); 1838 coex_dm->tdma_adj_type = 14; 1839 } else if (coex_dm->cur_ps_tdma == 14) { 1840 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1841 true, 15); 1842 coex_dm->tdma_adj_type = 15; 1843 } else if (coex_dm->cur_ps_tdma == 15) { 1844 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1845 true, 16); 1846 coex_dm->tdma_adj_type = 16; 1847 } 1848 } else if (result == 1) { 1849 if (coex_dm->cur_ps_tdma == 8) { 1850 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1851 true, 7); 1852 coex_dm->tdma_adj_type = 7; 1853 } else if (coex_dm->cur_ps_tdma == 7) { 1854 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1855 true, 6); 1856 coex_dm->tdma_adj_type = 6; 1857 } else if (coex_dm->cur_ps_tdma == 6) { 1858 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1859 true, 6); 1860 coex_dm->tdma_adj_type = 6; 1861 } else if (coex_dm->cur_ps_tdma == 16) { 1862 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1863 true, 15); 1864 coex_dm->tdma_adj_type = 15; 1865 } else if (coex_dm->cur_ps_tdma == 15) { 1866 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1867 true, 14); 1868 coex_dm->tdma_adj_type = 14; 1869 } else if (coex_dm->cur_ps_tdma == 14) { 1870 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1871 true, 14); 1872 coex_dm->tdma_adj_type = 14; 1873 } 1874 } 1875 } else { 1876 BTC_PRINT(BTC_MSG_ALGORITHM, 1877 ALGO_TRACE_FW_DETAIL, 1878 "[BTCoex], TxPause = 0\n"); 1879 if (coex_dm->cur_ps_tdma == 5) { 1880 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2); 1881 coex_dm->tdma_adj_type = 2; 1882 } else if (coex_dm->cur_ps_tdma == 6) { 1883 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2); 1884 coex_dm->tdma_adj_type = 2; 1885 } else if (coex_dm->cur_ps_tdma == 7) { 1886 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 1887 coex_dm->tdma_adj_type = 3; 1888 } else if (coex_dm->cur_ps_tdma == 8) { 1889 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4); 1890 coex_dm->tdma_adj_type = 4; 1891 } 1892 if (coex_dm->cur_ps_tdma == 13) { 1893 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10); 1894 coex_dm->tdma_adj_type = 10; 1895 } else if (coex_dm->cur_ps_tdma == 14) { 1896 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10); 1897 coex_dm->tdma_adj_type = 10; 1898 } else if (coex_dm->cur_ps_tdma == 15) { 1899 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 1900 coex_dm->tdma_adj_type = 11; 1901 } else if (coex_dm->cur_ps_tdma == 16) { 1902 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12); 1903 coex_dm->tdma_adj_type = 12; 1904 } 1905 if (result == -1) { 1906 if (coex_dm->cur_ps_tdma == 1) { 1907 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1908 true, 2); 1909 coex_dm->tdma_adj_type = 2; 1910 } else if (coex_dm->cur_ps_tdma == 2) { 1911 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1912 true, 3); 1913 coex_dm->tdma_adj_type = 3; 1914 } else if (coex_dm->cur_ps_tdma == 3) { 1915 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1916 true, 4); 1917 coex_dm->tdma_adj_type = 4; 1918 } else if (coex_dm->cur_ps_tdma == 9) { 1919 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1920 true, 10); 1921 coex_dm->tdma_adj_type = 10; 1922 } else if (coex_dm->cur_ps_tdma == 10) { 1923 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1924 true, 11); 1925 coex_dm->tdma_adj_type = 11; 1926 } else if (coex_dm->cur_ps_tdma == 11) { 1927 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1928 true, 12); 1929 coex_dm->tdma_adj_type = 12; 1930 } 1931 } else if (result == 1) { 1932 if (coex_dm->cur_ps_tdma == 4) { 1933 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1934 true, 3); 1935 coex_dm->tdma_adj_type = 3; 1936 } else if (coex_dm->cur_ps_tdma == 3) { 1937 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1938 true, 2); 1939 coex_dm->tdma_adj_type = 2; 1940 } else if (coex_dm->cur_ps_tdma == 2) { 1941 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1942 true, 2); 1943 coex_dm->tdma_adj_type = 2; 1944 } else if (coex_dm->cur_ps_tdma == 12) { 1945 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1946 true, 11); 1947 coex_dm->tdma_adj_type = 11; 1948 } else if (coex_dm->cur_ps_tdma == 11) { 1949 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1950 true, 10); 1951 coex_dm->tdma_adj_type = 10; 1952 } else if (coex_dm->cur_ps_tdma == 10) { 1953 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1954 true, 10); 1955 coex_dm->tdma_adj_type = 10; 1956 } 1957 } 1958 } 1959 } 1960 1961 static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause, 1962 s32 result) 1963 { 1964 /* Set PS TDMA for max interval == 3 */ 1965 if (tx_pause) { 1966 BTC_PRINT(BTC_MSG_ALGORITHM, 1967 ALGO_TRACE_FW_DETAIL, 1968 "[BTCoex], TxPause = 1\n"); 1969 if (coex_dm->cur_ps_tdma == 1) { 1970 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7); 1971 coex_dm->tdma_adj_type = 7; 1972 } else if (coex_dm->cur_ps_tdma == 2) { 1973 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7); 1974 coex_dm->tdma_adj_type = 7; 1975 } else if (coex_dm->cur_ps_tdma == 3) { 1976 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7); 1977 coex_dm->tdma_adj_type = 7; 1978 } else if (coex_dm->cur_ps_tdma == 4) { 1979 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8); 1980 coex_dm->tdma_adj_type = 8; 1981 } 1982 if (coex_dm->cur_ps_tdma == 9) { 1983 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15); 1984 coex_dm->tdma_adj_type = 15; 1985 } else if (coex_dm->cur_ps_tdma == 10) { 1986 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15); 1987 coex_dm->tdma_adj_type = 15; 1988 } else if (coex_dm->cur_ps_tdma == 11) { 1989 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15); 1990 coex_dm->tdma_adj_type = 15; 1991 } else if (coex_dm->cur_ps_tdma == 12) { 1992 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16); 1993 coex_dm->tdma_adj_type = 16; 1994 } 1995 if (result == -1) { 1996 if (coex_dm->cur_ps_tdma == 5) { 1997 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 1998 true, 7); 1999 coex_dm->tdma_adj_type = 7; 2000 } else if (coex_dm->cur_ps_tdma == 6) { 2001 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2002 true, 7); 2003 coex_dm->tdma_adj_type = 7; 2004 } else if (coex_dm->cur_ps_tdma == 7) { 2005 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2006 true, 8); 2007 coex_dm->tdma_adj_type = 8; 2008 } else if (coex_dm->cur_ps_tdma == 13) { 2009 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2010 true, 15); 2011 coex_dm->tdma_adj_type = 15; 2012 } else if (coex_dm->cur_ps_tdma == 14) { 2013 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2014 true, 15); 2015 coex_dm->tdma_adj_type = 15; 2016 } else if (coex_dm->cur_ps_tdma == 15) { 2017 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2018 true, 16); 2019 coex_dm->tdma_adj_type = 16; 2020 } 2021 } else if (result == 1) { 2022 if (coex_dm->cur_ps_tdma == 8) { 2023 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2024 true, 7); 2025 coex_dm->tdma_adj_type = 7; 2026 } else if (coex_dm->cur_ps_tdma == 7) { 2027 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2028 true, 7); 2029 coex_dm->tdma_adj_type = 7; 2030 } else if (coex_dm->cur_ps_tdma == 6) { 2031 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2032 true, 7); 2033 coex_dm->tdma_adj_type = 7; 2034 } else if (coex_dm->cur_ps_tdma == 16) { 2035 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2036 true, 15); 2037 coex_dm->tdma_adj_type = 15; 2038 } else if (coex_dm->cur_ps_tdma == 15) { 2039 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2040 true, 15); 2041 coex_dm->tdma_adj_type = 15; 2042 } else if (coex_dm->cur_ps_tdma == 14) { 2043 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2044 true, 15); 2045 coex_dm->tdma_adj_type = 15; 2046 } 2047 } 2048 } else { 2049 BTC_PRINT(BTC_MSG_ALGORITHM, 2050 ALGO_TRACE_FW_DETAIL, 2051 "[BTCoex], TxPause = 0\n"); 2052 if (coex_dm->cur_ps_tdma == 5) { 2053 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 2054 coex_dm->tdma_adj_type = 3; 2055 } else if (coex_dm->cur_ps_tdma == 6) { 2056 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 2057 coex_dm->tdma_adj_type = 3; 2058 } else if (coex_dm->cur_ps_tdma == 7) { 2059 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3); 2060 coex_dm->tdma_adj_type = 3; 2061 } else if (coex_dm->cur_ps_tdma == 8) { 2062 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4); 2063 coex_dm->tdma_adj_type = 4; 2064 } 2065 if (coex_dm->cur_ps_tdma == 13) { 2066 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 2067 coex_dm->tdma_adj_type = 11; 2068 } else if (coex_dm->cur_ps_tdma == 14) { 2069 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 2070 coex_dm->tdma_adj_type = 11; 2071 } else if (coex_dm->cur_ps_tdma == 15) { 2072 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11); 2073 coex_dm->tdma_adj_type = 11; 2074 } else if (coex_dm->cur_ps_tdma == 16) { 2075 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12); 2076 coex_dm->tdma_adj_type = 12; 2077 } 2078 if (result == -1) { 2079 if (coex_dm->cur_ps_tdma == 1) { 2080 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2081 true, 3); 2082 coex_dm->tdma_adj_type = 3; 2083 } else if (coex_dm->cur_ps_tdma == 2) { 2084 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2085 true, 3); 2086 coex_dm->tdma_adj_type = 3; 2087 } else if (coex_dm->cur_ps_tdma == 3) { 2088 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2089 true, 4); 2090 coex_dm->tdma_adj_type = 4; 2091 } else if (coex_dm->cur_ps_tdma == 9) { 2092 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2093 true, 11); 2094 coex_dm->tdma_adj_type = 11; 2095 } else if (coex_dm->cur_ps_tdma == 10) { 2096 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2097 true, 11); 2098 coex_dm->tdma_adj_type = 11; 2099 } else if (coex_dm->cur_ps_tdma == 11) { 2100 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2101 true, 12); 2102 coex_dm->tdma_adj_type = 12; 2103 } 2104 } else if (result == 1) { 2105 if (coex_dm->cur_ps_tdma == 4) { 2106 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2107 true, 3); 2108 coex_dm->tdma_adj_type = 3; 2109 } else if (coex_dm->cur_ps_tdma == 3) { 2110 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2111 true, 3); 2112 coex_dm->tdma_adj_type = 3; 2113 } else if (coex_dm->cur_ps_tdma == 2) { 2114 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2115 true, 3); 2116 coex_dm->tdma_adj_type = 3; 2117 } else if (coex_dm->cur_ps_tdma == 12) { 2118 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2119 true, 11); 2120 coex_dm->tdma_adj_type = 11; 2121 } else if (coex_dm->cur_ps_tdma == 11) { 2122 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2123 true, 11); 2124 coex_dm->tdma_adj_type = 11; 2125 } else if (coex_dm->cur_ps_tdma == 10) { 2126 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, 2127 true, 11); 2128 coex_dm->tdma_adj_type = 11; 2129 } 2130 } 2131 } 2132 } 2133 2134 static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist, 2135 bool sco_hid, bool tx_pause, 2136 u8 max_interval) 2137 { 2138 static s32 up, dn, m, n, wait_count; 2139 /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/ 2140 s32 result; 2141 u8 retry_count = 0; 2142 2143 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, 2144 "[BTCoex], TdmaDurationAdjust()\n"); 2145 2146 if (!coex_dm->auto_tdma_adjust) { 2147 coex_dm->auto_tdma_adjust = true; 2148 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2149 "[BTCoex], first run TdmaDurationAdjust()!!\n"); 2150 if (sco_hid) { 2151 if (tx_pause) { 2152 if (max_interval == 1) { 2153 btc8723b2ant_ps_tdma(btcoexist, 2154 NORMAL_EXEC, 2155 true, 13); 2156 coex_dm->tdma_adj_type = 13; 2157 } else if (max_interval == 2) { 2158 btc8723b2ant_ps_tdma(btcoexist, 2159 NORMAL_EXEC, 2160 true, 14); 2161 coex_dm->tdma_adj_type = 14; 2162 } else if (max_interval == 3) { 2163 btc8723b2ant_ps_tdma(btcoexist, 2164 NORMAL_EXEC, 2165 true, 15); 2166 coex_dm->tdma_adj_type = 15; 2167 } else { 2168 btc8723b2ant_ps_tdma(btcoexist, 2169 NORMAL_EXEC, 2170 true, 15); 2171 coex_dm->tdma_adj_type = 15; 2172 } 2173 } else { 2174 if (max_interval == 1) { 2175 btc8723b2ant_ps_tdma(btcoexist, 2176 NORMAL_EXEC, 2177 true, 9); 2178 coex_dm->tdma_adj_type = 9; 2179 } else if (max_interval == 2) { 2180 btc8723b2ant_ps_tdma(btcoexist, 2181 NORMAL_EXEC, 2182 true, 10); 2183 coex_dm->tdma_adj_type = 10; 2184 } else if (max_interval == 3) { 2185 btc8723b2ant_ps_tdma(btcoexist, 2186 NORMAL_EXEC, 2187 true, 11); 2188 coex_dm->tdma_adj_type = 11; 2189 } else { 2190 btc8723b2ant_ps_tdma(btcoexist, 2191 NORMAL_EXEC, 2192 true, 11); 2193 coex_dm->tdma_adj_type = 11; 2194 } 2195 } 2196 } else { 2197 if (tx_pause) { 2198 if (max_interval == 1) { 2199 btc8723b2ant_ps_tdma(btcoexist, 2200 NORMAL_EXEC, 2201 true, 5); 2202 coex_dm->tdma_adj_type = 5; 2203 } else if (max_interval == 2) { 2204 btc8723b2ant_ps_tdma(btcoexist, 2205 NORMAL_EXEC, 2206 true, 6); 2207 coex_dm->tdma_adj_type = 6; 2208 } else if (max_interval == 3) { 2209 btc8723b2ant_ps_tdma(btcoexist, 2210 NORMAL_EXEC, 2211 true, 7); 2212 coex_dm->tdma_adj_type = 7; 2213 } else { 2214 btc8723b2ant_ps_tdma(btcoexist, 2215 NORMAL_EXEC, 2216 true, 7); 2217 coex_dm->tdma_adj_type = 7; 2218 } 2219 } else { 2220 if (max_interval == 1) { 2221 btc8723b2ant_ps_tdma(btcoexist, 2222 NORMAL_EXEC, 2223 true, 1); 2224 coex_dm->tdma_adj_type = 1; 2225 } else if (max_interval == 2) { 2226 btc8723b2ant_ps_tdma(btcoexist, 2227 NORMAL_EXEC, 2228 true, 2); 2229 coex_dm->tdma_adj_type = 2; 2230 } else if (max_interval == 3) { 2231 btc8723b2ant_ps_tdma(btcoexist, 2232 NORMAL_EXEC, 2233 true, 3); 2234 coex_dm->tdma_adj_type = 3; 2235 } else { 2236 btc8723b2ant_ps_tdma(btcoexist, 2237 NORMAL_EXEC, 2238 true, 3); 2239 coex_dm->tdma_adj_type = 3; 2240 } 2241 } 2242 } 2243 2244 up = 0; 2245 dn = 0; 2246 m = 1; 2247 n = 3; 2248 result = 0; 2249 wait_count = 0; 2250 } else { 2251 /*accquire the BT TRx retry count from BT_Info byte2*/ 2252 retry_count = coex_sta->bt_retry_cnt; 2253 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2254 "[BTCoex], retry_count = %d\n", retry_count); 2255 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2256 "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n", 2257 up, dn, m, n, wait_count); 2258 result = 0; 2259 wait_count++; 2260 /* no retry in the last 2-second duration*/ 2261 if (retry_count == 0) { 2262 up++; 2263 dn--; 2264 2265 if (dn <= 0) 2266 dn = 0; 2267 2268 if (up >= n) { 2269 wait_count = 0; 2270 n = 3; 2271 up = 0; 2272 dn = 0; 2273 result = 1; 2274 BTC_PRINT(BTC_MSG_ALGORITHM, 2275 ALGO_TRACE_FW_DETAIL, 2276 "[BTCoex], Increase wifi " 2277 "duration!!\n"); 2278 } /* <=3 retry in the last 2-second duration*/ 2279 } else if (retry_count <= 3) { 2280 up--; 2281 dn++; 2282 2283 if (up <= 0) 2284 up = 0; 2285 2286 if (dn == 2) { 2287 if (wait_count <= 2) 2288 m++; 2289 else 2290 m = 1; 2291 2292 if (m >= 20) 2293 m = 20; 2294 2295 n = 3 * m; 2296 up = 0; 2297 dn = 0; 2298 wait_count = 0; 2299 result = -1; 2300 BTC_PRINT(BTC_MSG_ALGORITHM, 2301 ALGO_TRACE_FW_DETAIL, 2302 "[BTCoex], Decrease wifi duration " 2303 "for retry_counter<3!!\n"); 2304 } 2305 } else { 2306 if (wait_count == 1) 2307 m++; 2308 else 2309 m = 1; 2310 2311 if (m >= 20) 2312 m = 20; 2313 2314 n = 3 * m; 2315 up = 0; 2316 dn = 0; 2317 wait_count = 0; 2318 result = -1; 2319 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2320 "[BTCoex], Decrease wifi duration " 2321 "for retry_counter>3!!\n"); 2322 } 2323 2324 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2325 "[BTCoex], max Interval = %d\n", max_interval); 2326 if (max_interval == 1) 2327 set_tdma_int1(btcoexist, tx_pause, result); 2328 else if (max_interval == 2) 2329 set_tdma_int2(btcoexist, tx_pause, result); 2330 else if (max_interval == 3) 2331 set_tdma_int3(btcoexist, tx_pause, result); 2332 } 2333 2334 /*if current PsTdma not match with the recorded one (when scan, dhcp..), 2335 *then we have to adjust it back to the previous recorded one. 2336 */ 2337 if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) { 2338 bool scan = false, link = false, roam = false; 2339 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2340 "[BTCoex], PsTdma type dismatch!!!, " 2341 "curPsTdma=%d, recordPsTdma=%d\n", 2342 coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type); 2343 2344 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 2345 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 2346 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 2347 2348 if (!scan && !link && !roam) 2349 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2350 coex_dm->tdma_adj_type); 2351 else 2352 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, 2353 "[BTCoex], roaming/link/scan is under" 2354 " progress, will adjust next time!!!\n"); 2355 } 2356 } 2357 2358 /* SCO only or SCO+PAN(HS) */ 2359 static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist) 2360 { 2361 u8 wifi_rssi_state; 2362 u32 wifi_bw; 2363 2364 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2365 0, 2, 15, 0); 2366 2367 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2368 2369 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4); 2370 2371 if (btc8723b_need_dec_pwr(btcoexist)) 2372 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2373 else 2374 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2375 2376 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2377 2378 /*for SCO quality at 11b/g mode*/ 2379 if (BTC_WIFI_BW_LEGACY == wifi_bw) 2380 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 2); 2381 else /*for SCO quality & wifi performance balance at 11n mode*/ 2382 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 8); 2383 2384 /*for voice quality */ 2385 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0); 2386 2387 /* sw mechanism */ 2388 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2389 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2390 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2391 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2392 false, false); 2393 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2394 true, 0x4); 2395 } else { 2396 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2397 false, false); 2398 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2399 true, 0x4); 2400 } 2401 } else { 2402 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2403 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2404 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2405 false, false); 2406 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2407 true, 0x4); 2408 } else { 2409 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2410 false, false); 2411 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2412 true, 0x4); 2413 } 2414 } 2415 } 2416 2417 static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist) 2418 { 2419 u8 wifi_rssi_state, bt_rssi_state; 2420 u32 wifi_bw; 2421 2422 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2423 0, 2, 15, 0); 2424 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2425 2426 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2427 2428 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2429 2430 if (btc8723b_need_dec_pwr(btcoexist)) 2431 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2432 else 2433 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2434 2435 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2436 2437 if (BTC_WIFI_BW_LEGACY == wifi_bw) /*/for HID at 11b/g mode*/ 2438 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2439 else /*for HID quality & wifi performance balance at 11n mode*/ 2440 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 9); 2441 2442 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2443 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) 2444 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9); 2445 else 2446 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13); 2447 2448 /* sw mechanism */ 2449 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2450 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2451 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2452 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2453 false, false); 2454 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2455 false, 0x18); 2456 } else { 2457 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2458 false, false); 2459 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2460 false, 0x18); 2461 } 2462 } else { 2463 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2464 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2465 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2466 false, false); 2467 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2468 false, 0x18); 2469 } else { 2470 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2471 false, false); 2472 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2473 false, 0x18); 2474 } 2475 } 2476 } 2477 2478 /*A2DP only / PAN(EDR) only/ A2DP+PAN(HS)*/ 2479 static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist) 2480 { 2481 u8 wifi_rssi_state, wifi_rssi_state1, bt_rssi_state; 2482 u32 wifi_bw; 2483 u8 ap_num = 0; 2484 2485 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2486 0, 2, 15, 0); 2487 wifi_rssi_state1 = btc8723b2ant_wifi_rssi_state(btcoexist, 2488 1, 2, 40, 0); 2489 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2490 2491 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num); 2492 2493 /* define the office environment */ 2494 /* driver don't know AP num in Linux, so we will never enter this if */ 2495 if (ap_num >= 10 && BTC_RSSI_HIGH(wifi_rssi_state1)) { 2496 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 2497 0x0); 2498 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2499 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2500 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0); 2501 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 2502 2503 /* sw mechanism */ 2504 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2505 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2506 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2507 false, false); 2508 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2509 true, 0x18); 2510 } else { 2511 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2512 false, false); 2513 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2514 true, 0x18); 2515 } 2516 return; 2517 } 2518 2519 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2520 2521 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2522 2523 if (btc8723b_need_dec_pwr(btcoexist)) 2524 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2525 else 2526 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2527 2528 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2529 2530 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2531 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) 2532 btc8723b2ant_tdma_duration_adjust(btcoexist, false, 2533 false, 1); 2534 else 2535 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1); 2536 2537 /* sw mechanism */ 2538 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2539 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2540 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2541 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2542 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2543 false, false); 2544 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2545 false, 0x18); 2546 } else { 2547 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2548 false, false); 2549 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2550 false, 0x18); 2551 } 2552 } else { 2553 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2554 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2555 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2556 false, false); 2557 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2558 false, 0x18); 2559 } else { 2560 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2561 false, false); 2562 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2563 false, 0x18); 2564 } 2565 } 2566 } 2567 2568 static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist) 2569 { 2570 u8 wifi_rssi_state; 2571 u32 wifi_bw; 2572 2573 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2574 0, 2, 15, 0); 2575 2576 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2577 2578 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2579 2580 if (btc8723b_need_dec_pwr(btcoexist)) 2581 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2582 else 2583 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2584 2585 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2586 2587 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2); 2588 2589 /* sw mechanism */ 2590 btcoexist->btc_get(btcoexist, 2591 BTC_GET_U4_WIFI_BW, &wifi_bw); 2592 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2593 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2594 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2595 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2596 false, false); 2597 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2598 false, 0x18); 2599 } else { 2600 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2601 false, false); 2602 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2603 false, 0x18); 2604 } 2605 } else { 2606 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2607 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2608 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2609 false, false); 2610 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2611 false, 0x18); 2612 } else { 2613 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2614 false, false); 2615 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2616 false, 0x18); 2617 } 2618 } 2619 } 2620 2621 static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist) 2622 { 2623 u8 wifi_rssi_state, bt_rssi_state; 2624 u32 wifi_bw; 2625 2626 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2627 0, 2, 15, 0); 2628 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2629 2630 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2631 2632 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2633 2634 if (btc8723b_need_dec_pwr(btcoexist)) 2635 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2636 else 2637 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2638 2639 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 10); 2640 2641 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2642 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) 2643 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1); 2644 else 2645 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5); 2646 2647 /* sw mechanism */ 2648 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2649 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2650 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2651 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2652 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2653 false, false); 2654 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2655 false, 0x18); 2656 } else { 2657 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2658 false, false); 2659 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2660 false, 0x18); 2661 } 2662 } else { 2663 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2664 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2665 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2666 false, false); 2667 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2668 false, 0x18); 2669 } else { 2670 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2671 false, false); 2672 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2673 false, 0x18); 2674 } 2675 } 2676 } 2677 2678 /*PAN(HS) only*/ 2679 static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist) 2680 { 2681 u8 wifi_rssi_state; 2682 u32 wifi_bw; 2683 2684 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2685 0, 2, 15, 0); 2686 2687 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2688 2689 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2690 2691 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2692 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) 2693 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2694 else 2695 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2696 2697 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2698 2699 btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1); 2700 2701 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2702 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2703 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2704 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2705 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2706 false, false); 2707 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2708 false, 0x18); 2709 } else { 2710 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2711 false, false); 2712 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2713 false, 0x18); 2714 } 2715 } else { 2716 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2717 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2718 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2719 false, false); 2720 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2721 false, 0x18); 2722 } else { 2723 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2724 false, false); 2725 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2726 false, 0x18); 2727 } 2728 } 2729 } 2730 2731 /*PAN(EDR)+A2DP*/ 2732 static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist) 2733 { 2734 u8 wifi_rssi_state, bt_rssi_state; 2735 u32 wifi_bw; 2736 2737 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2738 0, 2, 15, 0); 2739 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2740 2741 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2742 2743 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2744 2745 if (btc8723b_need_dec_pwr(btcoexist)) 2746 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2747 else 2748 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2749 2750 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2751 2752 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2753 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2754 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 12); 2755 if (BTC_WIFI_BW_HT40 == wifi_bw) 2756 btc8723b2ant_tdma_duration_adjust(btcoexist, false, 2757 true, 3); 2758 else 2759 btc8723b2ant_tdma_duration_adjust(btcoexist, false, 2760 false, 3); 2761 } else { 2762 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2763 btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 3); 2764 } 2765 2766 /* sw mechanism */ 2767 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2768 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2769 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2770 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2771 false, false); 2772 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2773 false, 0x18); 2774 } else { 2775 btc8723b2ant_sw_mechanism1(btcoexist, true, false, 2776 false, false); 2777 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2778 false, 0x18); 2779 } 2780 } else { 2781 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2782 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2783 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2784 false, false); 2785 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2786 false, 0x18); 2787 } else { 2788 btc8723b2ant_sw_mechanism1(btcoexist, false, false, 2789 false, false); 2790 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2791 false, 0x18); 2792 } 2793 } 2794 } 2795 2796 static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist) 2797 { 2798 u8 wifi_rssi_state, bt_rssi_state; 2799 u32 wifi_bw; 2800 2801 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2802 0, 2, 15, 0); 2803 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2804 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2805 2806 if (btc8723b_need_dec_pwr(btcoexist)) 2807 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2808 else 2809 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2810 2811 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2812 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2813 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2814 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 2815 3); 2816 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11); 2817 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 2818 0xfffff, 0x780); 2819 } else { 2820 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 2821 6); 2822 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2823 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 2824 0xfffff, 0x0); 2825 } 2826 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2); 2827 } else { 2828 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2829 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11); 2830 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 2831 0x0); 2832 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2); 2833 } 2834 2835 /* sw mechanism */ 2836 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2837 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2838 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2839 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2840 false, false); 2841 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2842 false, 0x18); 2843 } else { 2844 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2845 false, false); 2846 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2847 false, 0x18); 2848 } 2849 } else { 2850 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2851 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2852 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2853 false, false); 2854 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2855 false, 0x18); 2856 } else { 2857 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2858 false, false); 2859 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2860 false, 0x18); 2861 } 2862 } 2863 } 2864 2865 /* HID+A2DP+PAN(EDR) */ 2866 static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist) 2867 { 2868 u8 wifi_rssi_state, bt_rssi_state; 2869 u32 wifi_bw; 2870 2871 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2872 0, 2, 15, 0); 2873 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2874 2875 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2876 2877 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2878 2879 if (btc8723b_need_dec_pwr(btcoexist)) 2880 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2881 else 2882 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2883 2884 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2885 2886 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2887 2888 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2889 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2890 if (BTC_WIFI_BW_HT40 == wifi_bw) 2891 btc8723b2ant_tdma_duration_adjust(btcoexist, true, 2892 true, 2); 2893 else 2894 btc8723b2ant_tdma_duration_adjust(btcoexist, true, 2895 false, 3); 2896 } else { 2897 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3); 2898 } 2899 2900 /* sw mechanism */ 2901 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2902 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2903 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2904 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2905 false, false); 2906 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2907 false, 0x18); 2908 } else { 2909 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2910 false, false); 2911 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2912 false, 0x18); 2913 } 2914 } else { 2915 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2916 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2917 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2918 false, false); 2919 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2920 false, 0x18); 2921 } else { 2922 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2923 false, false); 2924 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2925 false, 0x18); 2926 } 2927 } 2928 } 2929 2930 static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist) 2931 { 2932 u8 wifi_rssi_state, bt_rssi_state; 2933 u32 wifi_bw; 2934 2935 wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist, 2936 0, 2, 15, 0); 2937 bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 29, 0); 2938 2939 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2940 2941 btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6); 2942 2943 if (btc8723b_need_dec_pwr(btcoexist)) 2944 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true); 2945 else 2946 btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false); 2947 2948 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 2949 2950 btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7); 2951 2952 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) || 2953 (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) 2954 btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2); 2955 else 2956 btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2); 2957 2958 /* sw mechanism */ 2959 if (BTC_WIFI_BW_HT40 == wifi_bw) { 2960 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2961 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2962 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2963 false, false); 2964 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2965 false, 0x18); 2966 } else { 2967 btc8723b2ant_sw_mechanism1(btcoexist, true, true, 2968 false, false); 2969 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2970 false, 0x18); 2971 } 2972 } else { 2973 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) || 2974 (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) { 2975 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2976 false, false); 2977 btc8723b2ant_sw_mechanism2(btcoexist, true, false, 2978 false, 0x18); 2979 } else { 2980 btc8723b2ant_sw_mechanism1(btcoexist, false, true, 2981 false, false); 2982 btc8723b2ant_sw_mechanism2(btcoexist, false, false, 2983 false, 0x18); 2984 } 2985 } 2986 } 2987 2988 static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist) 2989 { 2990 u8 algorithm = 0; 2991 2992 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 2993 "[BTCoex], RunCoexistMechanism()===>\n"); 2994 2995 if (btcoexist->manual_control) { 2996 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 2997 "[BTCoex], RunCoexistMechanism(), " 2998 "return for Manual CTRL <===\n"); 2999 return; 3000 } 3001 3002 if (coex_sta->under_ips) { 3003 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3004 "[BTCoex], wifi is under IPS !!!\n"); 3005 return; 3006 } 3007 3008 algorithm = btc8723b2ant_action_algorithm(btcoexist); 3009 if (coex_sta->c2h_bt_inquiry_page && 3010 (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) { 3011 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3012 "[BTCoex], BT is under inquiry/page scan !!\n"); 3013 btc8723b2ant_action_bt_inquiry(btcoexist); 3014 return; 3015 } else { 3016 if (coex_dm->need_recover_0x948) { 3017 coex_dm->need_recover_0x948 = false; 3018 btcoexist->btc_write_2byte(btcoexist, 0x948, 3019 coex_dm->backup_0x948); 3020 } 3021 } 3022 3023 coex_dm->cur_algorithm = algorithm; 3024 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Algorithm = %d\n", 3025 coex_dm->cur_algorithm); 3026 3027 if (btc8723b2ant_is_common_action(btcoexist)) { 3028 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3029 "[BTCoex], Action 2-Ant common.\n"); 3030 coex_dm->auto_tdma_adjust = false; 3031 } else { 3032 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) { 3033 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3034 "[BTCoex], preAlgorithm=%d, " 3035 "curAlgorithm=%d\n", coex_dm->pre_algorithm, 3036 coex_dm->cur_algorithm); 3037 coex_dm->auto_tdma_adjust = false; 3038 } 3039 switch (coex_dm->cur_algorithm) { 3040 case BT_8723B_2ANT_COEX_ALGO_SCO: 3041 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3042 "[BTCoex], Action 2-Ant, algorithm = SCO.\n"); 3043 btc8723b2ant_action_sco(btcoexist); 3044 break; 3045 case BT_8723B_2ANT_COEX_ALGO_HID: 3046 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3047 "[BTCoex], Action 2-Ant, algorithm = HID.\n"); 3048 btc8723b2ant_action_hid(btcoexist); 3049 break; 3050 case BT_8723B_2ANT_COEX_ALGO_A2DP: 3051 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3052 "[BTCoex], Action 2-Ant, " 3053 "algorithm = A2DP.\n"); 3054 btc8723b2ant_action_a2dp(btcoexist); 3055 break; 3056 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS: 3057 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3058 "[BTCoex], Action 2-Ant, " 3059 "algorithm = A2DP+PAN(HS).\n"); 3060 btc8723b2ant_action_a2dp_pan_hs(btcoexist); 3061 break; 3062 case BT_8723B_2ANT_COEX_ALGO_PANEDR: 3063 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3064 "[BTCoex], Action 2-Ant, " 3065 "algorithm = PAN(EDR).\n"); 3066 btc8723b2ant_action_pan_edr(btcoexist); 3067 break; 3068 case BT_8723B_2ANT_COEX_ALGO_PANHS: 3069 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3070 "[BTCoex], Action 2-Ant, " 3071 "algorithm = HS mode.\n"); 3072 btc8723b2ant_action_pan_hs(btcoexist); 3073 break; 3074 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP: 3075 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3076 "[BTCoex], Action 2-Ant, " 3077 "algorithm = PAN+A2DP.\n"); 3078 btc8723b2ant_action_pan_edr_a2dp(btcoexist); 3079 break; 3080 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID: 3081 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3082 "[BTCoex], Action 2-Ant, " 3083 "algorithm = PAN(EDR)+HID.\n"); 3084 btc8723b2ant_action_pan_edr_hid(btcoexist); 3085 break; 3086 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR: 3087 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3088 "[BTCoex], Action 2-Ant, " 3089 "algorithm = HID+A2DP+PAN.\n"); 3090 btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist); 3091 break; 3092 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP: 3093 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3094 "[BTCoex], Action 2-Ant, " 3095 "algorithm = HID+A2DP.\n"); 3096 btc8723b2ant_action_hid_a2dp(btcoexist); 3097 break; 3098 default: 3099 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3100 "[BTCoex], Action 2-Ant, " 3101 "algorithm = coexist All Off!!\n"); 3102 btc8723b2ant_coex_alloff(btcoexist); 3103 break; 3104 } 3105 coex_dm->pre_algorithm = coex_dm->cur_algorithm; 3106 } 3107 } 3108 3109 static void btc8723b2ant_wifioff_hwcfg(struct btc_coexist *btcoexist) 3110 { 3111 /* set wlan_act to low */ 3112 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); 3113 /* Force GNT_BT to High */ 3114 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3); 3115 /* BT select s0/s1 is controlled by BT */ 3116 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x0); 3117 } 3118 3119 /********************************************************************* 3120 * work around function start with wa_btc8723b2ant_ 3121 *********************************************************************/ 3122 /********************************************************************* 3123 * extern function start with EXbtc8723b2ant_ 3124 *********************************************************************/ 3125 void ex_btc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist) 3126 { 3127 u8 u8tmp = 0; 3128 3129 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3130 "[BTCoex], 2Ant Init HW Config!!\n"); 3131 coex_dm->bt_rf0x1e_backup = 3132 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff); 3133 3134 /* 0x790[5:0] = 0x5 */ 3135 u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790); 3136 u8tmp &= 0xc0; 3137 u8tmp |= 0x5; 3138 btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp); 3139 3140 /*Antenna config */ 3141 btc8723b2ant_set_ant_path(btcoexist, BTC_ANT_WIFI_AT_MAIN, 3142 true, false); 3143 /* PTA parameter */ 3144 btc8723b_coex_tbl_type(btcoexist, FORCE_EXEC, 0); 3145 3146 /* Enable counter statistics */ 3147 /*0x76e[3] =1, WLAN_Act control by PTA*/ 3148 btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); 3149 btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3); 3150 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1); 3151 } 3152 3153 void ex_btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist) 3154 { 3155 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3156 "[BTCoex], Coex Mechanism Init!!\n"); 3157 btc8723b2ant_init_coex_dm(btcoexist); 3158 } 3159 3160 void ex_btc8723b2ant_display_coex_info(struct btc_coexist *btcoexist) 3161 { 3162 struct btc_board_info *board_info = &btcoexist->board_info; 3163 struct btc_stack_info *stack_info = &btcoexist->stack_info; 3164 struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info; 3165 struct rtl_priv *rtlpriv = btcoexist->adapter; 3166 u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0; 3167 u32 u32tmp[4]; 3168 bool roam = false, scan = false; 3169 bool link = false, wifi_under_5g = false; 3170 bool bt_hs_on = false, wifi_busy = false; 3171 s32 wifi_rssi = 0, bt_hs_rssi = 0; 3172 u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck; 3173 u8 wifi_dot11_chnl, wifi_hs_chnl; 3174 u32 fw_ver = 0, bt_patch_ver = 0; 3175 u8 ap_num = 0; 3176 3177 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3178 "\r\n ============[BT Coexist info]============"); 3179 3180 if (btcoexist->manual_control) { 3181 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3182 "\r\n ==========[Under Manual Control]============"); 3183 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3184 "\r\n =========================================="); 3185 } 3186 3187 if (!board_info->bt_exist) { 3188 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!"); 3189 return; 3190 } 3191 3192 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ", 3193 "Ant PG number/ Ant mechanism:", 3194 board_info->pg_ant_num, board_info->btdm_ant_num); 3195 3196 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %d", 3197 "BT stack/ hci ext ver", 3198 ((stack_info->profile_notified) ? "Yes" : "No"), 3199 stack_info->hci_version); 3200 3201 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver); 3202 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 3203 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3204 "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", 3205 "CoexVer/ FwVer/ PatchVer", 3206 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant, 3207 fw_ver, bt_patch_ver, bt_patch_ver); 3208 3209 btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); 3210 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL, 3211 &wifi_dot11_chnl); 3212 btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl); 3213 3214 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d(%d)", 3215 "Dot11 channel / HsChnl(HsMode)", 3216 wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on); 3217 3218 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %02x %02x %02x ", 3219 "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info[0], 3220 coex_dm->wifi_chnl_info[1], coex_dm->wifi_chnl_info[2]); 3221 3222 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); 3223 btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi); 3224 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM, &ap_num); 3225 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d", 3226 "Wifi rssi/ HS rssi/ AP#", wifi_rssi, bt_hs_rssi, ap_num); 3227 3228 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); 3229 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); 3230 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); 3231 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ", 3232 "Wifi link/ roam/ scan", link, roam, scan); 3233 3234 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g); 3235 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); 3236 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); 3237 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, 3238 &wifi_traffic_dir); 3239 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s / %s/ %s ", 3240 "Wifi status", (wifi_under_5g ? "5G" : "2.4G"), 3241 ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" : 3242 (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))), 3243 ((!wifi_busy) ? "idle" : 3244 ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ? 3245 "uplink" : "downlink"))); 3246 3247 3248 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d / %d / %d / %d", 3249 "SCO/HID/PAN/A2DP", 3250 bt_link_info->sco_exist, bt_link_info->hid_exist, 3251 bt_link_info->pan_exist, bt_link_info->a2dp_exist); 3252 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO); 3253 3254 bt_info_ext = coex_sta->bt_info_ext; 3255 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s", 3256 "BT Info A2DP rate", 3257 (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate"); 3258 3259 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) { 3260 if (coex_sta->bt_info_c2h_cnt[i]) { 3261 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3262 "\r\n %-35s = %02x %02x %02x " 3263 "%02x %02x %02x %02x(%d)", 3264 glbt_info_src_8723b_2ant[i], 3265 coex_sta->bt_info_c2h[i][0], 3266 coex_sta->bt_info_c2h[i][1], 3267 coex_sta->bt_info_c2h[i][2], 3268 coex_sta->bt_info_c2h[i][3], 3269 coex_sta->bt_info_c2h[i][4], 3270 coex_sta->bt_info_c2h[i][5], 3271 coex_sta->bt_info_c2h[i][6], 3272 coex_sta->bt_info_c2h_cnt[i]); 3273 } 3274 } 3275 3276 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s", 3277 "PS state, IPS/LPS", 3278 ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")), 3279 ((coex_sta->under_lps ? "LPS ON" : "LPS OFF"))); 3280 btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD); 3281 3282 /* Sw mechanism */ 3283 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3284 "\r\n %-35s", "============[Sw mechanism]============"); 3285 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d ", 3286 "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink, 3287 coex_dm->cur_low_penalty_ra, coex_dm->limited_dig); 3288 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d/ %d(0x%x) ", 3289 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", 3290 coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off, 3291 coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl); 3292 3293 /* Fw mechanism */ 3294 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s", 3295 "============[Fw mechanism]============"); 3296 3297 ps_tdma_case = coex_dm->cur_ps_tdma; 3298 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3299 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)", 3300 "PS TDMA", coex_dm->ps_tdma_para[0], 3301 coex_dm->ps_tdma_para[1], coex_dm->ps_tdma_para[2], 3302 coex_dm->ps_tdma_para[3], coex_dm->ps_tdma_para[4], 3303 ps_tdma_case, coex_dm->auto_tdma_adjust); 3304 3305 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d ", 3306 "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr, 3307 coex_dm->cur_ignore_wlan_act); 3308 3309 /* Hw setting */ 3310 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s", 3311 "============[Hw setting]============"); 3312 3313 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x", 3314 "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup); 3315 3316 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778); 3317 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880); 3318 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x", 3319 "0x778/0x880[29:25]", u8tmp[0], 3320 (u32tmp[0]&0x3e000000) >> 25); 3321 3322 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948); 3323 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67); 3324 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765); 3325 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 3326 "0x948/ 0x67[5] / 0x765", 3327 u32tmp[0], ((u8tmp[0]&0x20) >> 5), u8tmp[1]); 3328 3329 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c); 3330 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930); 3331 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944); 3332 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 3333 "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]", 3334 u32tmp[0]&0x3, u32tmp[1]&0xff, u32tmp[2]&0x3); 3335 3336 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39); 3337 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40); 3338 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c); 3339 u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64); 3340 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3341 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", 3342 "0x38[11]/0x40/0x4c[24:23]/0x64[0]", 3343 ((u8tmp[0] & 0x8)>>3), u8tmp[1], 3344 ((u32tmp[0]&0x01800000)>>23), u8tmp[2]&0x1); 3345 3346 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550); 3347 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522); 3348 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x", 3349 "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]); 3350 3351 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50); 3352 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c); 3353 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x", 3354 "0xc50(dig)/0x49c(null-drop)", u32tmp[0]&0xff, u8tmp[0]); 3355 3356 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0); 3357 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4); 3358 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8); 3359 u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0); 3360 3361 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b); 3362 u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c); 3363 3364 fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) + 3365 ((u32tmp[1]&0xffff0000) >> 16) + 3366 (u32tmp[1] & 0xffff) + 3367 (u32tmp[2] & 0xffff) + 3368 ((u32tmp[3]&0xffff0000) >> 16) + 3369 (u32tmp[3] & 0xffff); 3370 fa_cck = (u8tmp[0] << 8) + u8tmp[1]; 3371 3372 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", 3373 "OFDM-CCA/OFDM-FA/CCK-FA", 3374 u32tmp[0]&0xffff, fa_ofdm, fa_cck); 3375 3376 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0); 3377 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4); 3378 u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8); 3379 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc); 3380 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, 3381 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", 3382 "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", 3383 u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]); 3384 3385 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d", 3386 "0x770(high-pri rx/tx)", 3387 coex_sta->high_priority_rx, coex_sta->high_priority_tx); 3388 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d", 3389 "0x774(low-pri rx/tx)", coex_sta->low_priority_rx, 3390 coex_sta->low_priority_tx); 3391 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1) 3392 btc8723b2ant_monitor_bt_ctr(btcoexist); 3393 #endif 3394 btcoexist->btc_disp_dbg_msg(btcoexist, 3395 BTC_DBG_DISP_COEX_STATISTICS); 3396 } 3397 3398 void ex_btc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type) 3399 { 3400 if (BTC_IPS_ENTER == type) { 3401 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3402 "[BTCoex], IPS ENTER notify\n"); 3403 coex_sta->under_ips = true; 3404 btc8723b2ant_wifioff_hwcfg(btcoexist); 3405 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true); 3406 btc8723b2ant_coex_alloff(btcoexist); 3407 } else if (BTC_IPS_LEAVE == type) { 3408 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3409 "[BTCoex], IPS LEAVE notify\n"); 3410 coex_sta->under_ips = false; 3411 ex_btc8723b2ant_init_hwconfig(btcoexist); 3412 btc8723b2ant_init_coex_dm(btcoexist); 3413 btc8723b2ant_query_bt_info(btcoexist); 3414 } 3415 } 3416 3417 void ex_btc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type) 3418 { 3419 if (BTC_LPS_ENABLE == type) { 3420 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3421 "[BTCoex], LPS ENABLE notify\n"); 3422 coex_sta->under_lps = true; 3423 } else if (BTC_LPS_DISABLE == type) { 3424 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3425 "[BTCoex], LPS DISABLE notify\n"); 3426 coex_sta->under_lps = false; 3427 } 3428 } 3429 3430 void ex_btc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type) 3431 { 3432 if (BTC_SCAN_START == type) 3433 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3434 "[BTCoex], SCAN START notify\n"); 3435 else if (BTC_SCAN_FINISH == type) 3436 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3437 "[BTCoex], SCAN FINISH notify\n"); 3438 } 3439 3440 void ex_btc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type) 3441 { 3442 if (BTC_ASSOCIATE_START == type) 3443 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3444 "[BTCoex], CONNECT START notify\n"); 3445 else if (BTC_ASSOCIATE_FINISH == type) 3446 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3447 "[BTCoex], CONNECT FINISH notify\n"); 3448 } 3449 3450 void ex_btc8723b2ant_media_status_notify(struct btc_coexist *btcoexist, 3451 u8 type) 3452 { 3453 u8 h2c_parameter[3] = {0}; 3454 u32 wifi_bw; 3455 u8 wifi_central_chnl; 3456 3457 if (BTC_MEDIA_CONNECT == type) 3458 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3459 "[BTCoex], MEDIA connect notify\n"); 3460 else 3461 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3462 "[BTCoex], MEDIA disconnect notify\n"); 3463 3464 /* only 2.4G we need to inform bt the chnl mask */ 3465 btcoexist->btc_get(btcoexist, 3466 BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl); 3467 if ((BTC_MEDIA_CONNECT == type) && 3468 (wifi_central_chnl <= 14)) { 3469 h2c_parameter[0] = 0x1; 3470 h2c_parameter[1] = wifi_central_chnl; 3471 btcoexist->btc_get(btcoexist, 3472 BTC_GET_U4_WIFI_BW, &wifi_bw); 3473 if (BTC_WIFI_BW_HT40 == wifi_bw) 3474 h2c_parameter[2] = 0x30; 3475 else 3476 h2c_parameter[2] = 0x20; 3477 } 3478 3479 coex_dm->wifi_chnl_info[0] = h2c_parameter[0]; 3480 coex_dm->wifi_chnl_info[1] = h2c_parameter[1]; 3481 coex_dm->wifi_chnl_info[2] = h2c_parameter[2]; 3482 3483 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, 3484 "[BTCoex], FW write 0x66=0x%x\n", 3485 h2c_parameter[0] << 16 | h2c_parameter[1] << 8 | 3486 h2c_parameter[2]); 3487 3488 btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter); 3489 } 3490 3491 void ex_btc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist, 3492 u8 type) 3493 { 3494 if (type == BTC_PACKET_DHCP) 3495 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3496 "[BTCoex], DHCP Packet notify\n"); 3497 } 3498 3499 void ex_btc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist, 3500 u8 *tmpbuf, u8 length) 3501 { 3502 u8 bt_info = 0; 3503 u8 i, rsp_source = 0; 3504 bool bt_busy = false, limited_dig = false; 3505 bool wifi_connected = false; 3506 3507 coex_sta->c2h_bt_info_req_sent = false; 3508 3509 rsp_source = tmpbuf[0]&0xf; 3510 if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX) 3511 rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW; 3512 coex_sta->bt_info_c2h_cnt[rsp_source]++; 3513 3514 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3515 "[BTCoex], Bt info[%d], length=%d, hex data=[", 3516 rsp_source, length); 3517 for (i = 0; i < length; i++) { 3518 coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i]; 3519 if (i == 1) 3520 bt_info = tmpbuf[i]; 3521 if (i == length-1) 3522 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3523 "0x%02x]\n", tmpbuf[i]); 3524 else 3525 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, 3526 "0x%02x, ", tmpbuf[i]); 3527 } 3528 3529 if (btcoexist->manual_control) { 3530 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3531 "[BTCoex], BtInfoNotify(), " 3532 "return for Manual CTRL<===\n"); 3533 return; 3534 } 3535 3536 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) { 3537 coex_sta->bt_retry_cnt = /* [3:0]*/ 3538 coex_sta->bt_info_c2h[rsp_source][2] & 0xf; 3539 3540 coex_sta->bt_rssi = 3541 coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10; 3542 3543 coex_sta->bt_info_ext = 3544 coex_sta->bt_info_c2h[rsp_source][4]; 3545 3546 /* Here we need to resend some wifi info to BT 3547 because bt is reset and loss of the info. 3548 */ 3549 if ((coex_sta->bt_info_ext & BIT1)) { 3550 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3551 "[BTCoex], BT ext info bit1 check," 3552 " send wifi BW&Chnl to BT!!\n"); 3553 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, 3554 &wifi_connected); 3555 if (wifi_connected) 3556 ex_btc8723b2ant_media_status_notify( 3557 btcoexist, 3558 BTC_MEDIA_CONNECT); 3559 else 3560 ex_btc8723b2ant_media_status_notify( 3561 btcoexist, 3562 BTC_MEDIA_DISCONNECT); 3563 } 3564 3565 if ((coex_sta->bt_info_ext & BIT3)) { 3566 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3567 "[BTCoex], BT ext info bit3 check, " 3568 "set BT NOT to ignore Wlan active!!\n"); 3569 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, 3570 false); 3571 } else { 3572 /* BT already NOT ignore Wlan active, do nothing here.*/ 3573 } 3574 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0) 3575 if ((coex_sta->bt_info_ext & BIT4)) { 3576 /* BT auto report already enabled, do nothing*/ 3577 } else { 3578 btc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC, 3579 true); 3580 } 3581 #endif 3582 } 3583 3584 /* check BIT2 first ==> check if bt is under inquiry or page scan*/ 3585 if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE) 3586 coex_sta->c2h_bt_inquiry_page = true; 3587 else 3588 coex_sta->c2h_bt_inquiry_page = false; 3589 3590 /* set link exist status*/ 3591 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) { 3592 coex_sta->bt_link_exist = false; 3593 coex_sta->pan_exist = false; 3594 coex_sta->a2dp_exist = false; 3595 coex_sta->hid_exist = false; 3596 coex_sta->sco_exist = false; 3597 } else { /* connection exists */ 3598 coex_sta->bt_link_exist = true; 3599 if (bt_info & BT_INFO_8723B_2ANT_B_FTP) 3600 coex_sta->pan_exist = true; 3601 else 3602 coex_sta->pan_exist = false; 3603 if (bt_info & BT_INFO_8723B_2ANT_B_A2DP) 3604 coex_sta->a2dp_exist = true; 3605 else 3606 coex_sta->a2dp_exist = false; 3607 if (bt_info & BT_INFO_8723B_2ANT_B_HID) 3608 coex_sta->hid_exist = true; 3609 else 3610 coex_sta->hid_exist = false; 3611 if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) 3612 coex_sta->sco_exist = true; 3613 else 3614 coex_sta->sco_exist = false; 3615 } 3616 3617 btc8723b2ant_update_bt_link_info(btcoexist); 3618 3619 if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) { 3620 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE; 3621 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3622 "[BTCoex], BtInfoNotify(), " 3623 "BT Non-Connected idle!!!\n"); 3624 /* connection exists but no busy */ 3625 } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) { 3626 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE; 3627 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3628 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n"); 3629 } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) || 3630 (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) { 3631 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY; 3632 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3633 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n"); 3634 } else if (bt_info&BT_INFO_8723B_2ANT_B_ACL_BUSY) { 3635 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY; 3636 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3637 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n"); 3638 } else { 3639 coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX; 3640 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3641 "[BTCoex], BtInfoNotify(), " 3642 "BT Non-Defined state!!!\n"); 3643 } 3644 3645 if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) || 3646 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || 3647 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) { 3648 bt_busy = true; 3649 limited_dig = true; 3650 } else { 3651 bt_busy = false; 3652 limited_dig = false; 3653 } 3654 3655 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy); 3656 3657 coex_dm->limited_dig = limited_dig; 3658 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig); 3659 3660 btc8723b2ant_run_coexist_mechanism(btcoexist); 3661 } 3662 3663 void ex_btc8723b2ant_halt_notify(struct btc_coexist *btcoexist) 3664 { 3665 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n"); 3666 3667 btc8723b2ant_wifioff_hwcfg(btcoexist); 3668 btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true); 3669 ex_btc8723b2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT); 3670 } 3671 3672 void ex_btc8723b2ant_periodical(struct btc_coexist *btcoexist) 3673 { 3674 struct btc_board_info *board_info = &btcoexist->board_info; 3675 struct btc_stack_info *stack_info = &btcoexist->stack_info; 3676 static u8 dis_ver_info_cnt; 3677 u32 fw_ver = 0, bt_patch_ver = 0; 3678 3679 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, 3680 "[BTCoex], ==========================" 3681 "Periodical===========================\n"); 3682 3683 if (dis_ver_info_cnt <= 5) { 3684 dis_ver_info_cnt += 1; 3685 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3686 "[BTCoex], ****************************" 3687 "************************************\n"); 3688 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3689 "[BTCoex], Ant PG Num/ Ant Mech/ " 3690 "Ant Pos = %d/ %d/ %d\n", board_info->pg_ant_num, 3691 board_info->btdm_ant_num, board_info->btdm_ant_pos); 3692 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3693 "[BTCoex], BT stack/ hci ext ver = %s / %d\n", 3694 ((stack_info->profile_notified) ? "Yes" : "No"), 3695 stack_info->hci_version); 3696 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, 3697 &bt_patch_ver); 3698 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver); 3699 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3700 "[BTCoex], CoexVer/ fw_ver/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n", 3701 glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant, 3702 fw_ver, bt_patch_ver, bt_patch_ver); 3703 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, 3704 "[BTCoex], *****************************" 3705 "***********************************\n"); 3706 } 3707 3708 #if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0) 3709 btc8723b2ant_query_bt_info(btcoexist); 3710 btc8723b2ant_monitor_bt_ctr(btcoexist); 3711 btc8723b2ant_monitor_bt_enable_disable(btcoexist); 3712 #else 3713 if (btc8723b2ant_is_wifi_status_changed(btcoexist) || 3714 coex_dm->auto_tdma_adjust) 3715 btc8723b2ant_run_coexist_mechanism(btcoexist); 3716 #endif 3717 } 3718