drivers/staging/rtl8821ae/btcoexist/halbtc8723b1ant.c

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