drivers/net/wireless/rockchip_wlan/rtl8723cs/hal/btc/halbtc8723d2ant.c

   1 /* ************************************************************
   2  * Description:
   3  *
   4  * This file is for RTL8723D Co-exist mechanism
   5  *
   6  * History
   7  * 2012/11/15 Cosa first check in.
   8  *
   9  * ************************************************************ */
  10
  11 /* ************************************************************
  12  * include files
  13  * ************************************************************ */
  14 #include "mp_precomp.h"
  15
  16 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
  17
  18 #if (RTL8723D_SUPPORT == 1)
  19 /* ************************************************************
  20  * Global variables, these are static variables
  21  * ************************************************************ */
  22 static u8       *trace_buf = &gl_btc_trace_buf[0];
  23 static struct  coex_dm_8723d_2ant               glcoex_dm_8723d_2ant;
  24 static struct  coex_dm_8723d_2ant       *coex_dm = &glcoex_dm_8723d_2ant;
  25 static struct  coex_sta_8723d_2ant              glcoex_sta_8723d_2ant;
  26 static struct  coex_sta_8723d_2ant      *coex_sta = &glcoex_sta_8723d_2ant;
  27 static struct  psdscan_sta_8723d_2ant   gl_psd_scan_8723d_2ant;
  28 static struct  psdscan_sta_8723d_2ant *psd_scan = &gl_psd_scan_8723d_2ant;
  29
  30 const char *const glbt_info_src_8723d_2ant[] = {
  31         "BT Info[wifi fw]",
  32         "BT Info[bt rsp]",
  33         "BT Info[bt auto report]",
  34 };
  35 /* ************************************************************
  36  * BtCoex Version Format:
  37  * 1. date :                    glcoex_ver_date_XXXXX_1ant
  38  * 2. WifiCoexVersion : glcoex_ver_XXXX_1ant
  39  * 3. BtCoexVersion :   glcoex_ver_btdesired_XXXXX_1ant
  40  * 4. others :                  glcoex_ver_XXXXXX_XXXXX_1ant
  41  *
  42  * Variable should be indicated IC and Antenna numbers !!!
  43  * Please strictly follow this order and naming style !!!
  44  *
  45  * ************************************************************ */
  46 u32     glcoex_ver_date_8723d_2ant = 20161027;
  47 u32     glcoex_ver_8723d_2ant = 0x0f;
  48 u32 glcoex_ver_btdesired_8723d_2ant = 0x0d;
  49
  50
  51 /* ************************************************************
  52  * local function proto type if needed
  53  * ************************************************************
  54  * ************************************************************
  55  * local function start with halbtc8723d2ant_
  56  * ************************************************************ */
  57 u8 halbtc8723d2ant_bt_rssi_state(u8 *ppre_bt_rssi_state, u8 level_num,
  58                                  u8 rssi_thresh, u8 rssi_thresh1)
  59 {
  60         s32                     bt_rssi = 0;
  61         u8                      bt_rssi_state = *ppre_bt_rssi_state;
  62
  63         bt_rssi = coex_sta->bt_rssi;
  64
  65         if (level_num == 2) {
  66                 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  67                     (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  68                         if (bt_rssi >= (rssi_thresh +
  69                                         BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
  70                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  71                         else
  72                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  73                 } else {
  74                         if (bt_rssi < rssi_thresh)
  75                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
  76                         else
  77                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  78                 }
  79         } else if (level_num == 3) {
  80                 if (rssi_thresh > rssi_thresh1) {
  81                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
  82                                     "[BTCoex], BT Rssi thresh error!!\n");
  83                         BTC_TRACE(trace_buf);
  84                         return *ppre_bt_rssi_state;
  85                 }
  86
  87                 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  88                     (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  89                         if (bt_rssi >= (rssi_thresh +
  90                                         BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
  91                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
  92                         else
  93                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  94                 } else if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
  95                         (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
  96                         if (bt_rssi >= (rssi_thresh1 +
  97                                         BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
  98                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  99                         else if (bt_rssi < rssi_thresh)
 100                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
 101                         else
 102                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 103                 } else {
 104                         if (bt_rssi < rssi_thresh1)
 105                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 106                         else
 107                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 108                 }
 109         }
 110
 111         *ppre_bt_rssi_state = bt_rssi_state;
 112
 113         return bt_rssi_state;
 114 }
 115
 116 u8 halbtc8723d2ant_wifi_rssi_state(IN struct btc_coexist *btcoexist,
 117            IN u8 *pprewifi_rssi_state, IN u8 level_num, IN u8 rssi_thresh,
 118                                    IN u8 rssi_thresh1)
 119 {
 120         s32                     wifi_rssi = 0;
 121         u8                      wifi_rssi_state = *pprewifi_rssi_state;
 122
 123         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 124
 125         if (level_num == 2) {
 126                 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
 127                     (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 128                         if (wifi_rssi >= (rssi_thresh +
 129                                           BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
 130                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 131                         else
 132                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 133                 } else {
 134                         if (wifi_rssi < rssi_thresh)
 135                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 136                         else
 137                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 138                 }
 139         } else if (level_num == 3) {
 140                 if (rssi_thresh > rssi_thresh1) {
 141                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 142                                     "[BTCoex], wifi RSSI thresh error!!\n");
 143                         BTC_TRACE(trace_buf);
 144                         return *pprewifi_rssi_state;
 145                 }
 146
 147                 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
 148                     (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 149                         if (wifi_rssi >= (rssi_thresh +
 150                                           BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
 151                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 152                         else
 153                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 154                 } else if ((*pprewifi_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
 155                         (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
 156                         if (wifi_rssi >= (rssi_thresh1 +
 157                                           BTC_RSSI_COEX_THRESH_TOL_8723D_2ANT))
 158                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 159                         else if (wifi_rssi < rssi_thresh)
 160                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 161                         else
 162                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 163                 } else {
 164                         if (wifi_rssi < rssi_thresh1)
 165                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 166                         else
 167                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 168                 }
 169         }
 170
 171         *pprewifi_rssi_state = wifi_rssi_state;
 172
 173         return wifi_rssi_state;
 174 }
 175
 176 void halbtc8723d2ant_coex_switch_threshold(IN struct btc_coexist *btcoexist,
 177                 IN u8 isolation_measuared)
 178 {
 179         s8      interference_wl_tx = 0, interference_bt_tx = 0;
 180
 181
 182         interference_wl_tx = BT_8723D_2ANT_WIFI_MAX_TX_POWER -
 183                              isolation_measuared;
 184         interference_bt_tx = BT_8723D_2ANT_BT_MAX_TX_POWER -
 185                              isolation_measuared;
 186
 187
 188
 189         coex_sta->wifi_coex_thres                = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
 190         coex_sta->wifi_coex_thres2       = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES2;
 191
 192         coex_sta->bt_coex_thres          = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
 193         coex_sta->bt_coex_thres2                 = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES2;
 194
 195
 196         /*
 197                 coex_sta->wifi_coex_thres               = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES1;
 198                 coex_sta->wifi_coex_thres2              = interference_wl_tx + BT_8723D_2ANT_WIFI_SIR_THRES2;
 199
 200                 coex_sta->bt_coex_thres         = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES1;
 201                 coex_sta->bt_coex_thres2                = interference_bt_tx + BT_8723D_2ANT_BT_SIR_THRES2;
 202         */
 203
 204
 205
 206
 207
 208         /*
 209                 if  ( BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
 210                                         BT_8723D_2ANT_DEFAULT_ISOLATION) )
 211                         coex_sta->wifi_coex_thres        = BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1;
 212                 else
 213                         coex_sta->wifi_coex_thres =  BT_8723D_2ANT_WIFI_RSSI_COEXSWITCH_THRES1 -  (isolation_measuared -
 214                                         BT_8723D_2ANT_DEFAULT_ISOLATION);
 215
 216                 if  ( BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 < (isolation_measuared -
 217                                         BT_8723D_2ANT_DEFAULT_ISOLATION) )
 218                         coex_sta->bt_coex_thres  = BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1;
 219                 else
 220                         coex_sta->bt_coex_thres =  BT_8723D_2ANT_BT_RSSI_COEXSWITCH_THRES1 -  (isolation_measuared -
 221                                         BT_8723D_2ANT_DEFAULT_ISOLATION);
 222
 223         */
 224 }
 225
 226
 227 void halbtc8723d2ant_limited_rx(IN struct btc_coexist *btcoexist,
 228                         IN boolean force_exec, IN boolean rej_ap_agg_pkt,
 229                         IN boolean bt_ctrl_agg_buf_size, IN u8 agg_buf_size)
 230 {
 231         boolean reject_rx_agg = rej_ap_agg_pkt;
 232         boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
 233         u8      rx_agg_size = agg_buf_size;
 234
 235         /* ============================================ */
 236         /*      Rx Aggregation related setting */
 237         /* ============================================ */
 238         btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT,
 239                            &reject_rx_agg);
 240         /* decide BT control aggregation buf size or not */
 241         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
 242                            &bt_ctrl_rx_agg_size);
 243         /* aggregation buf size, only work when BT control Rx aggregation size. */
 244         btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
 245         /* real update aggregation setting */
 246         btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 247 }
 248
 249 void halbtc8723d2ant_query_bt_info(IN struct btc_coexist *btcoexist)
 250 {
 251         u8                      h2c_parameter[1] = {0};
 252
 253
 254         h2c_parameter[0] |= BIT(0);     /* trigger */
 255
 256         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 257 }
 258
 259 void halbtc8723d2ant_monitor_bt_ctr(IN struct btc_coexist *btcoexist)
 260 {
 261         u32                     reg_hp_txrx, reg_lp_txrx, u32tmp;
 262         u32                     reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
 263         static u8               num_of_bt_counter_chk = 0, cnt_slave = 0, cnt_overhead = 0,
 264                                 cnt_autoslot_hang = 0;
 265
 266         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 267
 268         reg_hp_txrx = 0x770;
 269         reg_lp_txrx = 0x774;
 270
 271         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 272         reg_hp_tx = u32tmp & MASKLWORD;
 273         reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
 274
 275         u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 276         reg_lp_tx = u32tmp & MASKLWORD;
 277         reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
 278
 279         coex_sta->high_priority_tx = reg_hp_tx;
 280         coex_sta->high_priority_rx = reg_hp_rx;
 281         coex_sta->low_priority_tx = reg_lp_tx;
 282         coex_sta->low_priority_rx = reg_lp_rx;
 283
 284         if (BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
 285                 coex_dm->bt_status) {
 286
 287                         if (coex_sta->high_priority_rx >= 15) {
 288                                         if (cnt_overhead < 3)
 289                                                 cnt_overhead++;
 290
 291                                         if (cnt_overhead == 3)
 292                                                 coex_sta->is_hiPri_rx_overhead = true;
 293                          } else {
 294                                         if (cnt_overhead > 0)
 295                                                 cnt_overhead--;
 296
 297                                         if (cnt_overhead == 0)
 298                                                 coex_sta->is_hiPri_rx_overhead = false;
 299                         }
 300         }
 301
 302         /* reset counter */
 303         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 304
 305         if ((coex_sta->low_priority_tx > 1050)  &&
 306             (!coex_sta->c2h_bt_inquiry_page))
 307                 coex_sta->pop_event_cnt++;
 308
 309         if ((coex_sta->low_priority_rx >= 950) &&
 310             (coex_sta->low_priority_rx >= coex_sta->low_priority_tx)
 311             && (!coex_sta->under_ips)  && (!coex_sta->c2h_bt_inquiry_page) &&
 312             (coex_sta->bt_link_exist))  {
 313                 if (cnt_slave >= 2) {
 314                         bt_link_info->slave_role = true;
 315                         cnt_slave = 2;
 316                 } else
 317                         cnt_slave++;
 318         } else {
 319                 if (cnt_slave == 0)     {
 320                         bt_link_info->slave_role = false;
 321                         cnt_slave = 0;
 322                 } else
 323                         cnt_slave--;
 324
 325         }
 326
 327         if (coex_sta->is_tdma_btautoslot) {
 328                 if ((coex_sta->low_priority_tx >= 1300) &&
 329                         (coex_sta->low_priority_rx <= 150)) {
 330                         if (cnt_autoslot_hang >= 2) {
 331                                 coex_sta->is_tdma_btautoslot_hang = true;
 332                                 cnt_autoslot_hang = 2;
 333                         } else
 334                                 cnt_autoslot_hang++;
 335                 } else {
 336                         if (cnt_autoslot_hang == 0)     {
 337                                 coex_sta->is_tdma_btautoslot_hang = false;
 338                                 cnt_autoslot_hang = 0;
 339                         } else
 340                                 cnt_autoslot_hang--;
 341                 }
 342         }
 343
 344         if (!coex_sta->bt_disabled) {
 345
 346                 if ((coex_sta->high_priority_tx == 0) &&
 347                     (coex_sta->high_priority_rx == 0) &&
 348                     (coex_sta->low_priority_tx == 0) &&
 349                     (coex_sta->low_priority_rx == 0)) {
 350                         num_of_bt_counter_chk++;
 351                         if (num_of_bt_counter_chk >= 3) {
 352                                 halbtc8723d2ant_query_bt_info(btcoexist);
 353                                 num_of_bt_counter_chk = 0;
 354                         }
 355                 }
 356         }
 357
 358 }
 359
 360 void halbtc8723d2ant_monitor_wifi_ctr(IN struct btc_coexist *btcoexist)
 361 {
 362 #if 1
 363                 s32 wifi_rssi = 0;
 364                 boolean wifi_busy = false, wifi_under_b_mode = false,
 365                                 wifi_scan = false;
 366                 boolean bt_idle = false, wl_idle = false;
 367                 static u8 cck_lock_counter = 0, wl_noisy_count0 = 0,
 368                                 wl_noisy_count1 = 3, wl_noisy_count2 = 0;
 369                 u32 total_cnt, reg_val1, reg_val2, cck_cnt;
 370
 371                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 372                 btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 373                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
 374                                    &wifi_under_b_mode);
 375
 376                 coex_sta->crc_ok_cck = btcoexist->btc_phydm_query_PHY_counter(
 377                                                                 btcoexist, PHYDM_INFO_CRC32_OK_CCK);
 378                 coex_sta->crc_ok_11g = btcoexist->btc_phydm_query_PHY_counter(
 379                                                                 btcoexist, PHYDM_INFO_CRC32_OK_LEGACY);
 380                 coex_sta->crc_ok_11n = btcoexist->btc_phydm_query_PHY_counter(
 381                                                                 btcoexist, PHYDM_INFO_CRC32_OK_HT);
 382                 coex_sta->crc_ok_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
 383                                                                 btcoexist, PHYDM_INFO_CRC32_OK_VHT);
 384
 385                 coex_sta->crc_err_cck = btcoexist->btc_phydm_query_PHY_counter(
 386                                                                 btcoexist, PHYDM_INFO_CRC32_ERROR_CCK);
 387                 coex_sta->crc_err_11g =  btcoexist->btc_phydm_query_PHY_counter(
 388                                                                 btcoexist, PHYDM_INFO_CRC32_ERROR_LEGACY);
 389                 coex_sta->crc_err_11n = btcoexist->btc_phydm_query_PHY_counter(
 390                                                                 btcoexist, PHYDM_INFO_CRC32_ERROR_HT);
 391                 coex_sta->crc_err_11n_vht = btcoexist->btc_phydm_query_PHY_counter(
 392                                                                 btcoexist, PHYDM_INFO_CRC32_ERROR_VHT);
 393
 394                 cck_cnt = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
 395
 396                 if (cck_cnt > 250) {
 397                         if (wl_noisy_count2 < 3)
 398                                 wl_noisy_count2++;
 399
 400                         if (wl_noisy_count2 == 3) {
 401                                 wl_noisy_count0 = 0;
 402                                 wl_noisy_count1 = 0;
 403                         }
 404                 } else if (cck_cnt < 50) {
 405                         if (wl_noisy_count0 < 3)
 406                                 wl_noisy_count0++;
 407
 408                         if (wl_noisy_count0 == 3) {
 409                                 wl_noisy_count1 = 0;
 410                                 wl_noisy_count2 = 0;
 411                         }
 412                 } else {
 413                         if (wl_noisy_count1 < 3)
 414                                 wl_noisy_count1++;
 415
 416                         if (wl_noisy_count1 == 3) {
 417                                 wl_noisy_count0 = 0;
 418                                 wl_noisy_count2 = 0;
 419                         }
 420                 }
 421
 422                 if (wl_noisy_count2 == 3)
 423                         coex_sta->wl_noisy_level = 2;
 424                 else if (wl_noisy_count1 == 3)
 425                         coex_sta->wl_noisy_level = 1;
 426                 else
 427                         coex_sta->wl_noisy_level = 0;
 428
 429                 if ((wifi_busy) && (wifi_rssi >= 30) && (!wifi_under_b_mode)) {
 430                         total_cnt = coex_sta->crc_ok_cck + coex_sta->crc_ok_11g +
 431                                         coex_sta->crc_ok_11n + coex_sta->crc_ok_11n_vht;
 432
 433                         if ((coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_BUSY) ||
 434                                 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY) ||
 435                                 (coex_dm->bt_status == BT_8723D_2ANT_BT_STATUS_SCO_BUSY)) {
 436                                 if (coex_sta->crc_ok_cck > (total_cnt -
 437                                                                 coex_sta->crc_ok_cck)) {
 438                                         if (cck_lock_counter < 3)
 439                                                 cck_lock_counter++;
 440                                 } else {
 441                                         if (cck_lock_counter > 0)
 442                                                 cck_lock_counter--;
 443                                 }
 444
 445                         } else {
 446                                 if (cck_lock_counter > 0)
 447                                         cck_lock_counter--;
 448                         }
 449                 } else {
 450                         if (cck_lock_counter > 0)
 451                                 cck_lock_counter--;
 452                 }
 453
 454                 if (!coex_sta->pre_ccklock) {
 455
 456                         if (cck_lock_counter >= 3)
 457                                 coex_sta->cck_lock = true;
 458                         else
 459                                 coex_sta->cck_lock = false;
 460                 } else {
 461                         if (cck_lock_counter == 0)
 462                                 coex_sta->cck_lock = false;
 463                         else
 464                                 coex_sta->cck_lock = true;
 465                 }
 466
 467                 if (coex_sta->cck_lock)
 468                         coex_sta->cck_ever_lock = true;
 469
 470                 coex_sta->pre_ccklock =  coex_sta->cck_lock;
 471
 472 #endif
 473 }
 474
 475
 476
 477 boolean halbtc8723d2ant_is_wifibt_status_changed(IN struct btc_coexist
 478                 *btcoexist)
 479 {
 480
 481         static boolean  pre_wifi_busy = false, pre_under_4way = false,
 482                 pre_bt_hs_on = false, pre_bt_off = false, pre_bt_slave = false;
 483         static u8 pre_hid_busy_num = 0, pre_wl_noisy_level = 0;
 484         boolean wifi_busy = false, under_4way = false, bt_hs_on = false;
 485         boolean wifi_connected = false;
 486         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 487
 488         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 489                            &wifi_connected);
 490         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 491         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 492         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 493                            &under_4way);
 494
 495         if (coex_sta->bt_disabled != pre_bt_off) {
 496                 pre_bt_off = coex_sta->bt_disabled;
 497
 498                 if (coex_sta->bt_disabled)
 499                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 500                                     "[BTCoex], BT is disabled !!\n");
 501                 else
 502                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 503                                     "[BTCoex], BT is enabled !!\n");
 504
 505                 BTC_TRACE(trace_buf);
 506
 507                 coex_sta->bt_coex_supported_feature = 0;
 508                 coex_sta->bt_coex_supported_version = 0;
 509                 coex_sta->bt_ble_scan_type = 0;
 510                 coex_sta->bt_ble_scan_para[0] = 0;
 511                 coex_sta->bt_ble_scan_para[1] = 0;
 512                 coex_sta->bt_ble_scan_para[2] = 0;
 513                 coex_sta->bt_reg_vendor_ac = 0xffff;
 514                 coex_sta->bt_reg_vendor_ae = 0xffff;
 515                 return true;
 516         }
 517
 518         if (wifi_connected) {
 519                 if (wifi_busy != pre_wifi_busy) {
 520                         pre_wifi_busy = wifi_busy;
 521                         return true;
 522                 }
 523                 if (under_4way != pre_under_4way) {
 524                         pre_under_4way = under_4way;
 525                         return true;
 526                 }
 527                 if (bt_hs_on != pre_bt_hs_on) {
 528                         pre_bt_hs_on = bt_hs_on;
 529                         return true;
 530                 }
 531                 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
 532                         pre_wl_noisy_level = coex_sta->wl_noisy_level;
 533                         return true;
 534                 }
 535         }
 536
 537         if (!coex_sta->bt_disabled) {
 538                 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
 539                         pre_hid_busy_num = coex_sta->hid_busy_num;
 540                         return true;
 541                 }
 542         }
 543
 544         if (bt_link_info->slave_role != pre_bt_slave) {
 545                         pre_bt_slave = bt_link_info->slave_role;
 546                         return true;
 547         }
 548
 549         return false;
 550 }
 551
 552 void halbtc8723d2ant_update_bt_link_info(IN struct btc_coexist *btcoexist)
 553 {
 554         struct  btc_bt_link_info        *bt_link_info = &btcoexist->bt_link_info;
 555         boolean                 bt_hs_on = false;
 556         boolean                 bt_busy = false;
 557
 558
 559         coex_sta->num_of_profile = 0;
 560
 561         /* set link exist status */
 562         if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
 563                 coex_sta->bt_link_exist = false;
 564                 coex_sta->pan_exist = false;
 565                 coex_sta->a2dp_exist = false;
 566                 coex_sta->hid_exist = false;
 567                 coex_sta->sco_exist = false;
 568         } else {        /* connection exists */
 569                 coex_sta->bt_link_exist = true;
 570                 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_FTP) {
 571                         coex_sta->pan_exist = true;
 572                         coex_sta->num_of_profile++;
 573                 } else
 574                         coex_sta->pan_exist = false;
 575
 576                 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_A2DP) {
 577                         coex_sta->a2dp_exist = true;
 578                         coex_sta->num_of_profile++;
 579                 } else
 580                         coex_sta->a2dp_exist = false;
 581
 582                 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_HID) {
 583                         coex_sta->hid_exist = true;
 584                         coex_sta->num_of_profile++;
 585                 } else
 586                         coex_sta->hid_exist = false;
 587
 588                 if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) {
 589                         coex_sta->sco_exist = true;
 590                         coex_sta->num_of_profile++;
 591                 } else
 592                         coex_sta->sco_exist = false;
 593
 594         }
 595
 596         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 597
 598         bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 599         bt_link_info->sco_exist = coex_sta->sco_exist;
 600         bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 601         bt_link_info->pan_exist = coex_sta->pan_exist;
 602         bt_link_info->hid_exist = coex_sta->hid_exist;
 603         bt_link_info->acl_busy = coex_sta->acl_busy;
 604
 605         /* work around for HS mode. */
 606         if (bt_hs_on) {
 607                 bt_link_info->pan_exist = true;
 608                 bt_link_info->bt_link_exist = true;
 609         }
 610
 611         /* check if Sco only */
 612         if (bt_link_info->sco_exist &&
 613             !bt_link_info->a2dp_exist &&
 614             !bt_link_info->pan_exist &&
 615             !bt_link_info->hid_exist)
 616                 bt_link_info->sco_only = true;
 617         else
 618                 bt_link_info->sco_only = false;
 619
 620         /* check if A2dp only */
 621         if (!bt_link_info->sco_exist &&
 622             bt_link_info->a2dp_exist &&
 623             !bt_link_info->pan_exist &&
 624             !bt_link_info->hid_exist)
 625                 bt_link_info->a2dp_only = true;
 626         else
 627                 bt_link_info->a2dp_only = false;
 628
 629         /* check if Pan only */
 630         if (!bt_link_info->sco_exist &&
 631             !bt_link_info->a2dp_exist &&
 632             bt_link_info->pan_exist &&
 633             !bt_link_info->hid_exist)
 634                 bt_link_info->pan_only = true;
 635         else
 636                 bt_link_info->pan_only = false;
 637
 638         /* check if Hid only */
 639         if (!bt_link_info->sco_exist &&
 640             !bt_link_info->a2dp_exist &&
 641             !bt_link_info->pan_exist &&
 642             bt_link_info->hid_exist)
 643                 bt_link_info->hid_only = true;
 644         else
 645                 bt_link_info->hid_only = false;
 646
 647         if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_INQ_PAGE) {
 648                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_INQ_PAGE;
 649                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 650                         "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
 651         } else if (!(coex_sta->bt_info & BT_INFO_8723D_2ANT_B_CONNECTION)) {
 652                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
 653                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 654                         "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
 655         } else if (coex_sta->bt_info == BT_INFO_8723D_2ANT_B_CONNECTION) {
 656                 /* connection exists but no busy */
 657                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE;
 658                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 659                             "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
 660         } else if (((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
 661                     (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) &&
 662                    (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY)) {
 663                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY;
 664                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 665                             "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
 666         } else if ((coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_ESCO) ||
 667                    (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_SCO_BUSY)) {
 668                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_SCO_BUSY;
 669                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 670                             "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
 671         } else if (coex_sta->bt_info & BT_INFO_8723D_2ANT_B_ACL_BUSY) {
 672                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_ACL_BUSY;
 673                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 674                             "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
 675         } else {
 676                 coex_dm->bt_status = BT_8723D_2ANT_BT_STATUS_MAX;
 677                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 678                         "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
 679         }
 680
 681         BTC_TRACE(trace_buf);
 682
 683         if ((BT_8723D_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
 684             (BT_8723D_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
 685             (BT_8723D_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
 686                 bt_busy = true;
 687         else
 688                 bt_busy = false;
 689
 690         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
 691 }
 692
 693 void halbtc8723d2ant_update_wifi_channel_info(IN struct btc_coexist *btcoexist,
 694                 IN u8 type)
 695 {
 696         u8                      h2c_parameter[3] = {0};
 697         u32                     wifi_bw;
 698         u8                      wifi_central_chnl;
 699
 700         /* only 2.4G we need to inform bt the chnl mask */
 701         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
 702                            &wifi_central_chnl);
 703         if ((BTC_MEDIA_CONNECT == type) &&
 704             (wifi_central_chnl <= 14)) {
 705                 h2c_parameter[0] =
 706                         0x1;  /* enable BT AFH skip WL channel for 8723d because BT Rx LO interference */
 707                 /* h2c_parameter[0] = 0x0; */
 708                 h2c_parameter[1] = wifi_central_chnl;
 709                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
 710                 if (BTC_WIFI_BW_HT40 == wifi_bw)
 711                         h2c_parameter[2] = 0x30;
 712                 else
 713                         h2c_parameter[2] = 0x20;
 714         }
 715
 716         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
 717         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
 718         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
 719
 720         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
 721
 722 }
 723
 724 void halbtc8723d2ant_set_fw_dac_swing_level(IN struct btc_coexist *btcoexist,
 725                 IN u8 dac_swing_lvl)
 726 {
 727         u8                      h2c_parameter[1] = {0};
 728
 729         /* There are several type of dacswing */
 730         /* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
 731         h2c_parameter[0] = dac_swing_lvl;
 732
 733         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 734 }
 735
 736 void halbtc8723d2ant_fw_dac_swing_lvl(IN struct btc_coexist *btcoexist,
 737                               IN boolean force_exec, IN u8 fw_dac_swing_lvl)
 738 {
 739         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 740
 741         if (!force_exec) {
 742                 if (coex_dm->pre_fw_dac_swing_lvl ==
 743                     coex_dm->cur_fw_dac_swing_lvl)
 744                         return;
 745         }
 746
 747         halbtc8723d2ant_set_fw_dac_swing_level(btcoexist,
 748                                                coex_dm->cur_fw_dac_swing_lvl);
 749
 750         coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
 751 }
 752
 753 void halbtc8723d2ant_set_fw_dec_bt_pwr(IN struct btc_coexist *btcoexist,
 754                                        IN u8 dec_bt_pwr_lvl)
 755 {
 756         u8                      h2c_parameter[1] = {0};
 757
 758         h2c_parameter[0] = dec_bt_pwr_lvl;
 759
 760         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 761 }
 762
 763 void halbtc8723d2ant_dec_bt_pwr(IN struct btc_coexist *btcoexist,
 764                                 IN boolean force_exec, IN u8 dec_bt_pwr_lvl)
 765 {
 766         coex_dm->cur_bt_dec_pwr_lvl = dec_bt_pwr_lvl;
 767
 768         if (!force_exec) {
 769                 if (coex_dm->pre_bt_dec_pwr_lvl == coex_dm->cur_bt_dec_pwr_lvl)
 770                         return;
 771         }
 772         halbtc8723d2ant_set_fw_dec_bt_pwr(btcoexist,
 773                                           coex_dm->cur_bt_dec_pwr_lvl);
 774
 775         coex_dm->pre_bt_dec_pwr_lvl = coex_dm->cur_bt_dec_pwr_lvl;
 776 }
 777
 778 void halbtc8723d2ant_set_fw_low_penalty_ra(IN struct btc_coexist
 779                 *btcoexist, IN boolean low_penalty_ra)
 780 {
 781 #if 1
 782         u8                      h2c_parameter[6] = {0};
 783
 784         h2c_parameter[0] = 0x6; /* op_code, 0x6= Retry_Penalty */
 785
 786         if (low_penalty_ra) {
 787                 h2c_parameter[1] |= BIT(0);
 788                 h2c_parameter[2] =
 789                         0x00;  /* normal rate except MCS7/6/5, OFDM54/48/36 */
 790                 h2c_parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
 791                 h2c_parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
 792                 h2c_parameter[5] = 0xf9;        /* MCS5 or OFDM36        */
 793         }
 794
 795         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 796 #endif
 797 }
 798
 799 void halbtc8723d2ant_low_penalty_ra(IN struct btc_coexist *btcoexist,
 800                             IN boolean force_exec, IN boolean low_penalty_ra)
 801 {
 802 #if 1
 803         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 804
 805         if (!force_exec) {
 806                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 807                         return;
 808         }
 809
 810         halbtc8723d2ant_set_fw_low_penalty_ra(btcoexist,
 811                                                           coex_dm->cur_low_penalty_ra);
 812
 813 #if 0
 814         if (low_penalty_ra)
 815                 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 15);
 816         else
 817                 btcoexist->btc_phydm_modify_RA_PCR_threshold(btcoexist, 0, 0);
 818 #endif
 819         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 820
 821 #endif
 822 }
 823
 824 void halbtc8723d2ant_set_bt_auto_report(IN struct btc_coexist *btcoexist,
 825                                         IN boolean enable_auto_report)
 826 {
 827         u8                      h2c_parameter[1] = {0};
 828
 829         h2c_parameter[0] = 0;
 830
 831         if (enable_auto_report)
 832                 h2c_parameter[0] |= BIT(0);
 833
 834         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 835 }
 836
 837 void halbtc8723d2ant_bt_auto_report(IN struct btc_coexist *btcoexist,
 838                     IN boolean force_exec, IN boolean enable_auto_report)
 839 {
 840         coex_dm->cur_bt_auto_report = enable_auto_report;
 841
 842         if (!force_exec) {
 843                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
 844                         return;
 845         }
 846         halbtc8723d2ant_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 halbtc8723d2ant_write_score_board(
 853         IN      struct  btc_coexist             *btcoexist,
 854         IN      u16                             bitpos,
 855         IN      boolean         state
 856 )
 857 {
 858
 859         static u16 originalval = 0x8002;
 860
 861         if (state)
 862                 originalval = originalval | bitpos;
 863         else
 864                 originalval = originalval & (~bitpos);
 865
 866
 867         btcoexist->btc_write_2byte(btcoexist, 0xaa, originalval);
 868
 869 }
 870
 871 void halbtc8723d2ant_read_score_board(
 872         IN      struct  btc_coexist             *btcoexist,
 873         IN   u16                                *score_board_val
 874 )
 875 {
 876
 877         *score_board_val = (btcoexist->btc_read_2byte(btcoexist,
 878                             0xaa)) & 0x7fff;
 879 }
 880
 881
 882 void halbtc8723d2ant_post_state_to_bt(
 883         IN      struct  btc_coexist             *btcoexist,
 884         IN      u16                                             type,
 885         IN  boolean                 state
 886 )
 887 {
 888
 889         halbtc8723d2ant_write_score_board(btcoexist, (u16) type, state);
 890
 891 }
 892
 893 void halbtc8723d2ant_monitor_bt_enable_disable(IN struct btc_coexist *btcoexist)
 894 {
 895         static u32              bt_disable_cnt = 0;
 896         boolean                 bt_active = true, bt_disabled = false;
 897         u16                     u16tmp;
 898
 899         /* This function check if bt is disabled */
 900 #if 0
 901         if (coex_sta->high_priority_tx == 0 &&
 902             coex_sta->high_priority_rx == 0 &&
 903             coex_sta->low_priority_tx == 0 &&
 904             coex_sta->low_priority_rx == 0)
 905                 bt_active = false;
 906         if (coex_sta->high_priority_tx == 0xffff &&
 907             coex_sta->high_priority_rx == 0xffff &&
 908             coex_sta->low_priority_tx == 0xffff &&
 909             coex_sta->low_priority_rx == 0xffff)
 910                 bt_active = false;
 911
 912
 913 #else
 914
 915         /* Read BT on/off status from scoreboard[1], enable this only if BT patch support this feature */
 916         halbtc8723d2ant_read_score_board(btcoexist,     &u16tmp);
 917
 918         bt_active = u16tmp & BIT(1);
 919
 920
 921 #endif
 922
 923         if (bt_active) {
 924                 bt_disable_cnt = 0;
 925                 bt_disabled = false;
 926                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
 927                                    &bt_disabled);
 928         } else {
 929
 930                 bt_disable_cnt++;
 931                 if (bt_disable_cnt >= 2) {
 932                         bt_disabled = true;
 933                         bt_disable_cnt = 2;
 934                 }
 935
 936                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
 937                                    &bt_disabled);
 938         }
 939
 940         if (bt_disabled)
 941                 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
 942         else
 943                 halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, true);
 944
 945         if (coex_sta->bt_disabled != bt_disabled) {
 946                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
 947                             "[BTCoex], BT is from %s to %s!!\n",
 948                             (coex_sta->bt_disabled ? "disabled" : "enabled"),
 949                             (bt_disabled ? "disabled" : "enabled"));
 950                 BTC_TRACE(trace_buf);
 951                 coex_sta->bt_disabled = bt_disabled;
 952         }
 953
 954 }
 955
 956
 957
 958 void halbtc8723d2ant_enable_gnt_to_gpio(IN struct btc_coexist *btcoexist,
 959                                         boolean isenable)
 960 {
 961 #if BT_8723D_2ANT_COEX_DBG
 962         if (isenable) {
 963                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x1);
 964
 965                 /* enable GNT_BT to GPIO debug */
 966                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x0);
 967                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x0);
 968
 969                 /* 0x48[20] = 0  for GPIO14 =  GNT_WL*/
 970                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x0);
 971                 /* 0x40[17] = 0  for GPIO14 =  GNT_WL*/
 972                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x42, 0x02, 0x0);
 973
 974                 /* 0x66[9] = 0   for GPIO15 =  GNT_BT*/
 975                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x02, 0x0);
 976                 /* 0x66[7] = 0
 977                 for GPIO15 =  GNT_BT*/
 978                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x66, 0x80, 0x0);
 979                 /* 0x8[8] = 0    for GPIO15 =  GNT_BT*/
 980                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x9, 0x1, 0x0);
 981
 982                 /* BT Vendor Reg 0x76[0] = 0  for GPIO15 =  GNT_BT, this is not set here*/
 983         } else {
 984                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x8, 0x0);
 985
 986                 /* Disable GNT_BT debug to GPIO, and enable chip_wakeup_host */
 987                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4e, 0x40, 0x1);
 988                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x1, 0x1);
 989
 990                 /* 0x48[20] = 0  for GPIO14 =  GNT_WL*/
 991                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4a, 0x10, 0x1);
 992         }
 993
 994 #endif
 995 }
 996
 997 u32 halbtc8723d2ant_ltecoex_indirect_read_reg(IN struct btc_coexist *btcoexist,
 998                 IN u16 reg_addr)
 999 {
1000         u32 j = 0;
1001
1002
1003         /* wait for ready bit before access 0x7c0                */
1004         btcoexist->btc_write_4byte(btcoexist, 0x7c0, 0x800F0000 | reg_addr);
1005
1006         do {
1007                 j++;
1008         } while (((btcoexist->btc_read_1byte(btcoexist,
1009                                              0x7c3)&BIT(5)) == 0) &&
1010                  (j < BT_8723D_2ANT_LTECOEX_INDIRECTREG_ACCESS_TIMEOUT));
1011
1012
1013         return btcoexist->btc_read_4byte(btcoexist,
1014                                          0x7c8);  /* get read data */
1015
1016 }
1017
1018 void halbtc8723d2ant_ltecoex_indirect_write_reg(IN struct btc_coexist
1019                 *btcoexist,
1020                 IN u16 reg_addr, IN u32 bit_mask, IN u32 reg_value)
1021 {
1022         u32 val, i = 0, j = 0, bitpos = 0;
1023
1024
1025         if (bit_mask == 0x0)
1026                 return;
1027         if (bit_mask == 0xffffffff) {
1028                 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1029                                            reg_value); /* put write data */
1030
1031                 /* wait for ready bit before access 0x7c0 */
1032                 do {
1033                         j++;
1034                 } while (((btcoexist->btc_read_1byte(btcoexist,
1035                                                      0x7c3)&BIT(5)) == 0) &&
1036                         (j < BT_8723D_2ANT_LTECOEX_INDIRECTREG_ACCESS_TIMEOUT));
1037
1038
1039                 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1040                                            0xc00F0000 | reg_addr);
1041         } else {
1042                 for (i = 0; i <= 31; i++) {
1043                         if (((bit_mask >> i) & 0x1) == 0x1) {
1044                                 bitpos = i;
1045                                 break;
1046                         }
1047                 }
1048
1049                 /* read back register value before write */
1050                 val = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1051                                 reg_addr);
1052                 val = (val & (~bit_mask)) | (reg_value << bitpos);
1053
1054                 btcoexist->btc_write_4byte(btcoexist, 0x7c4,
1055                                            val); /* put write data */
1056
1057                 /* wait for ready bit before access 0x7c0                */
1058                 do {
1059                         j++;
1060                 } while (((btcoexist->btc_read_1byte(btcoexist,
1061                                                      0x7c3)&BIT(5)) == 0) &&
1062                         (j < BT_8723D_2ANT_LTECOEX_INDIRECTREG_ACCESS_TIMEOUT));
1063
1064
1065                 btcoexist->btc_write_4byte(btcoexist, 0x7c0,
1066                                            0xc00F0000 | reg_addr);
1067
1068         }
1069
1070 }
1071
1072 void halbtc8723d2ant_ltecoex_enable(IN struct btc_coexist *btcoexist,
1073                                     IN boolean enable)
1074 {
1075         u8 val;
1076
1077         val = (enable) ? 1 : 0;
1078         halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, 0x38, 0x80,
1079                         val);  /* 0x38[7] */
1080
1081 }
1082
1083 void halbtc8723d2ant_ltecoex_pathcontrol_owner(IN struct btc_coexist *btcoexist,
1084                 IN boolean wifi_control)
1085 {
1086         u8 val;
1087
1088         val = (wifi_control) ? 1 : 0;
1089         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x73, 0x4,
1090                                            val); /* 0x70[26] */
1091
1092 }
1093
1094 void halbtc8723d2ant_ltecoex_set_gnt_bt(IN struct btc_coexist *btcoexist,
1095                         IN u8 control_block, IN boolean sw_control, IN u8 state)
1096 {
1097         u32 val = 0, val_orig = 0;
1098
1099         if (!sw_control)
1100                 val = 0x0;
1101         else if (state & 0x1)
1102                 val = 0x3;
1103         else
1104                 val = 0x1;
1105
1106         val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1107                                 0x38);
1108
1109         switch (control_block) {
1110         case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1111         default:
1112                 val = ((val << 14) | (val << 10)) | (val_orig & 0xffff33ff);
1113                 break;
1114         case BT_8723D_2ANT_GNT_BLOCK_RFC:
1115                 val = (val << 14) | (val_orig & 0xffff3fff);
1116                 break;
1117         case BT_8723D_2ANT_GNT_BLOCK_BB:
1118                 val = (val << 10) | (val_orig & 0xfffff3ff);
1119                 break;
1120         }
1121
1122         halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1123                                 0x38, 0xffffffff, val);
1124 }
1125
1126
1127 void halbtc8723d2ant_ltecoex_set_gnt_wl(IN struct btc_coexist *btcoexist,
1128                         IN u8 control_block, IN boolean sw_control, IN u8 state)
1129 {
1130         u32 val = 0, val_orig = 0;
1131
1132         if (!sw_control)
1133                 val = 0x0;
1134         else if (state & 0x1)
1135                 val = 0x3;
1136         else
1137                 val = 0x1;
1138
1139         val_orig = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1140                                 0x38);
1141
1142         switch (control_block) {
1143         case BT_8723D_2ANT_GNT_BLOCK_RFC_BB:
1144         default:
1145                 val = ((val << 12) | (val << 8)) | (val_orig & 0xffffccff);
1146                 break;
1147         case BT_8723D_2ANT_GNT_BLOCK_RFC:
1148                 val = (val << 12) | (val_orig & 0xffffcfff);
1149                 break;
1150         case BT_8723D_2ANT_GNT_BLOCK_BB:
1151                 val = (val << 8) | (val_orig & 0xfffffcff);
1152                 break;
1153         }
1154
1155         halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist,
1156                                 0x38, 0xffffffff, val);
1157 }
1158
1159 void halbtc8723d2ant_ltecoex_set_coex_table(IN struct btc_coexist *btcoexist,
1160                 IN u8 table_type, IN u16 table_content)
1161 {
1162         u16 reg_addr = 0x0000;
1163
1164         switch (table_type) {
1165         case BT_8723D_2ANT_CTT_WL_VS_LTE:
1166                 reg_addr = 0xa0;
1167                 break;
1168         case BT_8723D_2ANT_CTT_BT_VS_LTE:
1169                 reg_addr = 0xa4;
1170                 break;
1171         }
1172
1173         if (reg_addr != 0x0000)
1174                 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1175                         0xffff, table_content); /* 0xa0[15:0] or 0xa4[15:0] */
1176
1177
1178 }
1179
1180
1181 void halbtc8723d2ant_ltecoex_set_break_table(IN struct btc_coexist *btcoexist,
1182                 IN u8 table_type, IN u8 table_content)
1183 {
1184         u16 reg_addr = 0x0000;
1185
1186         switch (table_type) {
1187         case BT_8723D_2ANT_LBTT_WL_BREAK_LTE:
1188                 reg_addr = 0xa8;
1189                 break;
1190         case BT_8723D_2ANT_LBTT_BT_BREAK_LTE:
1191                 reg_addr = 0xac;
1192                 break;
1193         case BT_8723D_2ANT_LBTT_LTE_BREAK_WL:
1194                 reg_addr = 0xb0;
1195                 break;
1196         case BT_8723D_2ANT_LBTT_LTE_BREAK_BT:
1197                 reg_addr = 0xb4;
1198                 break;
1199         }
1200
1201         if (reg_addr != 0x0000)
1202                 halbtc8723d2ant_ltecoex_indirect_write_reg(btcoexist, reg_addr,
1203                         0xff, table_content); /* 0xa8[15:0] or 0xb4[15:0] */
1204
1205
1206 }
1207
1208 void halbtc8723d2ant_set_wltoggle_coex_table(IN struct btc_coexist *btcoexist,
1209                 IN boolean force_exec,  IN u8 interval,
1210                 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1, IN u8 val0x6c4_b2,
1211                 IN u8 val0x6c4_b3)
1212 {
1213         static u8 pre_h2c_parameter[6] = {0};
1214         u8      cur_h2c_parameter[6] = {0};
1215         u8 i, match_cnt = 0;
1216
1217         cur_h2c_parameter[0] = 0x7;     /* op_code, 0x7= wlan toggle slot*/
1218
1219         cur_h2c_parameter[1] = interval;
1220         cur_h2c_parameter[2] = val0x6c4_b0;
1221         cur_h2c_parameter[3] = val0x6c4_b1;
1222         cur_h2c_parameter[4] = val0x6c4_b2;
1223         cur_h2c_parameter[5] = val0x6c4_b3;
1224
1225         if (!force_exec) {
1226                 for (i = 1; i <= 5; i++) {
1227                         if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1228                                 break;
1229
1230                         match_cnt++;
1231                 }
1232
1233                 if (match_cnt == 5)
1234                         return;
1235         }
1236
1237         for (i = 1; i <= 5; i++)
1238                 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1239
1240         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, cur_h2c_parameter);
1241 }
1242
1243 void halbtc8723d2ant_set_coex_table(IN struct btc_coexist *btcoexist,
1244             IN u32 val0x6c0, IN u32 val0x6c4, IN u32 val0x6c8, IN u8 val0x6cc)
1245 {
1246         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
1247
1248         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
1249
1250         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
1251
1252         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
1253 }
1254
1255 void halbtc8723d2ant_coex_table(IN struct btc_coexist *btcoexist,
1256                         IN boolean force_exec, IN u32 val0x6c0, IN u32 val0x6c4,
1257                                 IN u32 val0x6c8, IN u8 val0x6cc)
1258 {
1259         coex_dm->cur_val0x6c0 = val0x6c0;
1260         coex_dm->cur_val0x6c4 = val0x6c4;
1261         coex_dm->cur_val0x6c8 = val0x6c8;
1262         coex_dm->cur_val0x6cc = val0x6cc;
1263
1264         if (!force_exec) {
1265                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1266                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1267                     (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1268                     (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1269                         return;
1270         }
1271         halbtc8723d2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1272                                        val0x6cc);
1273
1274         coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1275         coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1276         coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1277         coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1278 }
1279
1280 void halbtc8723d2ant_coex_table_with_type(IN struct btc_coexist *btcoexist,
1281                 IN boolean force_exec, IN u8 type)
1282 {
1283         u32     break_table;
1284         u8      select_table;
1285
1286         coex_sta->coex_table_type = type;
1287
1288         if (coex_sta->concurrent_rx_mode_on == true) {
1289                 break_table = 0xf0ffffff;  /* set WL hi-pri can break BT */
1290                 select_table =
1291                         0xb;            /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
1292         } else {
1293                 break_table = 0xffffff;
1294                 select_table = 0x3;
1295         }
1296
1297                 switch (type) {
1298                 case 0:
1299                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1300                                    0xffffffff, 0xffffffff, break_table, select_table);
1301                         break;
1302                 case 1:
1303                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1304                                    0x55555555, 0x5a5a5a5a, break_table, select_table);
1305                         break;
1306                 case 2:
1307                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1308                                    0x5a5a5a5a, 0x5a5a5a5a, break_table, select_table);
1309                         break;
1310                 case 3:
1311                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1312                                    0xaa555555, 0xaa5a5a5a, break_table, select_table);
1313                         break;
1314                 case 4:
1315                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1316                                    0x55555555, 0x5a5a5a5a, break_table, select_table);
1317                         break;
1318                 case 5:
1319                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1320                                    0x55555555, 0x55555555, break_table, select_table);
1321                         break;
1322                 case 6:
1323                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1324                                    0xa5555555, 0xfafafafa, break_table, select_table);
1325                         break;
1326                 case 7:
1327                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1328                                    0xa5555555, 0xaa5a5a5a, break_table, select_table);
1329                         break;
1330                 case 8:
1331                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1332                                    0xa5555555, 0xfafafafa, break_table, select_table);
1333                         break;
1334                 case 9:
1335                         halbtc8723d2ant_coex_table(btcoexist, force_exec,
1336                                    0x5a5a5a5a, 0xaaaa5aaa, break_table, select_table);
1337                         break;
1338                 default:
1339                         break;
1340                 }
1341 }
1342
1343 void halbtc8723d2ant_set_fw_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1344                 IN boolean enable)
1345 {
1346         u8                      h2c_parameter[1] = {0};
1347
1348         if (enable) {
1349                 h2c_parameter[0] |= BIT(0);             /* function enable */
1350         }
1351
1352         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1353 }
1354
1355 void halbtc8723d2ant_ignore_wlan_act(IN struct btc_coexist *btcoexist,
1356                                      IN boolean force_exec, IN boolean enable)
1357 {
1358         coex_dm->cur_ignore_wlan_act = enable;
1359
1360         if (!force_exec) {
1361                 if (coex_dm->pre_ignore_wlan_act ==
1362                     coex_dm->cur_ignore_wlan_act)
1363                         return;
1364         }
1365         halbtc8723d2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1366
1367         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1368 }
1369
1370 void halbtc8723d2ant_set_lps_rpwm(IN struct btc_coexist *btcoexist,
1371                                   IN u8 lps_val, IN u8 rpwm_val)
1372 {
1373         u8      lps = lps_val;
1374         u8      rpwm = rpwm_val;
1375
1376         btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
1377         btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
1378 }
1379
1380 void halbtc8723d2ant_lps_rpwm(IN struct btc_coexist *btcoexist,
1381                       IN boolean force_exec, IN u8 lps_val, IN u8 rpwm_val)
1382 {
1383         coex_dm->cur_lps = lps_val;
1384         coex_dm->cur_rpwm = rpwm_val;
1385
1386         if (!force_exec) {
1387                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
1388                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm))
1389                         return;
1390         }
1391         halbtc8723d2ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
1392
1393         coex_dm->pre_lps = coex_dm->cur_lps;
1394         coex_dm->pre_rpwm = coex_dm->cur_rpwm;
1395 }
1396
1397 void halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1398         IN struct btc_coexist *btcoexist, IN boolean new_ps_state)
1399 {
1400         u8      lps_mode = 0x0;
1401         u8      h2c_parameter[5] = {0, 0, 0, 0x40, 0};
1402
1403         btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode);
1404
1405         if (lps_mode) { /* already under LPS state */
1406                 if (new_ps_state) {
1407                         /* keep state under LPS, do nothing. */
1408                 } else {
1409                         /* will leave LPS state, turn off psTdma first */
1410                         /*halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1411                                                 8); */
1412                         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1413                                                 h2c_parameter);
1414                 }
1415         } else {                                        /* NO PS state */
1416                 if (new_ps_state) {
1417                         /* will enter LPS state, turn off psTdma first */
1418                         /*halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false,
1419                                                 8);*/
1420                         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5,
1421                                                 h2c_parameter);
1422                 } else {
1423                         /* keep state under NO PS state, do nothing. */
1424                 }
1425         }
1426 }
1427
1428 void halbtc8723d2ant_power_save_state(IN struct btc_coexist *btcoexist,
1429                               IN u8 ps_type, IN u8 lps_val, IN u8 rpwm_val)
1430 {
1431         boolean         low_pwr_disable = false;
1432
1433         switch (ps_type) {
1434         case BTC_PS_WIFI_NATIVE:
1435                 /* recover to original 32k low power setting */
1436                 low_pwr_disable = false;
1437                 btcoexist->btc_set(btcoexist,
1438                                    BTC_SET_ACT_DISABLE_LOW_POWER,
1439                                    &low_pwr_disable);
1440                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS,
1441                                    NULL);
1442                 coex_sta->force_lps_on = false;
1443                 break;
1444         case BTC_PS_LPS_ON:
1445                 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1446                         btcoexist, true);
1447                 halbtc8723d2ant_lps_rpwm(btcoexist, NORMAL_EXEC,
1448                                          lps_val, rpwm_val);
1449                 /* when coex force to enter LPS, do not enter 32k low power. */
1450                 low_pwr_disable = true;
1451                 btcoexist->btc_set(btcoexist,
1452                                    BTC_SET_ACT_DISABLE_LOW_POWER,
1453                                    &low_pwr_disable);
1454                 /* power save must executed before psTdma.                       */
1455                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS,
1456                                    NULL);
1457                 coex_sta->force_lps_on = true;
1458                 break;
1459         case BTC_PS_LPS_OFF:
1460                 halbtc8723d2ant_ps_tdma_check_for_power_save_state(
1461                         btcoexist, false);
1462                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS,
1463                                    NULL);
1464                 coex_sta->force_lps_on = false;
1465                 break;
1466         default:
1467                 break;
1468         }
1469 }
1470
1471
1472
1473 void halbtc8723d2ant_set_fw_pstdma(IN struct btc_coexist *btcoexist,
1474            IN u8 byte1, IN u8 byte2, IN u8 byte3, IN u8 byte4, IN u8 byte5)
1475 {
1476         u8                      h2c_parameter[5] = {0};
1477         u8                      real_byte1 = byte1, real_byte5 = byte5;
1478         boolean                 ap_enable = false;
1479         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1480
1481         if (byte5 & BIT(2))
1482                 coex_sta->is_tdma_btautoslot = true;
1483         else
1484                 coex_sta->is_tdma_btautoslot = false;
1485
1486         /* release bt-auto slot for auto-slot hang is detected!! */
1487         if (coex_sta->is_tdma_btautoslot)
1488                 if ((coex_sta->is_tdma_btautoslot_hang) ||
1489                         (bt_link_info->slave_role))
1490                         byte5 = byte5 & 0xfb;
1491
1492         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1493                            &ap_enable);
1494
1495         if (ap_enable) {
1496                 if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1497                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1498                                     "[BTCoex], FW for AP mode\n");
1499                         BTC_TRACE(trace_buf);
1500                         real_byte1 &= ~BIT(4);
1501                         real_byte1 |= BIT(5);
1502
1503                         real_byte5 |= BIT(5);
1504                         real_byte5 &= ~BIT(6);
1505
1506                         halbtc8723d2ant_power_save_state(btcoexist,
1507                                                  BTC_PS_WIFI_NATIVE, 0x0,
1508                                                          0x0);
1509                 }
1510         } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1511
1512                 halbtc8723d2ant_power_save_state(
1513                         btcoexist, BTC_PS_LPS_ON, 0x50,
1514                         0x4);
1515         } else {
1516                 halbtc8723d2ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1517                                                  0x0,
1518                                                  0x0);
1519         }
1520
1521
1522         h2c_parameter[0] = real_byte1;
1523         h2c_parameter[1] = byte2;
1524         h2c_parameter[2] = byte3;
1525         h2c_parameter[3] = byte4;
1526         h2c_parameter[4] = real_byte5;
1527
1528         coex_dm->ps_tdma_para[0] = real_byte1;
1529         coex_dm->ps_tdma_para[1] = byte2;
1530         coex_dm->ps_tdma_para[2] = byte3;
1531         coex_dm->ps_tdma_para[3] = byte4;
1532         coex_dm->ps_tdma_para[4] = real_byte5;
1533
1534         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1535 }
1536
1537 void halbtc8723d2ant_ps_tdma(IN struct btc_coexist *btcoexist,
1538                      IN boolean force_exec, IN boolean turn_on, IN u8 type)
1539 {
1540
1541         static u8                       psTdmaByte4Modify = 0x0, pre_psTdmaByte4Modify = 0x0;
1542         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1543
1544
1545         coex_dm->cur_ps_tdma_on = turn_on;
1546         coex_dm->cur_ps_tdma = type;
1547
1548         /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1549         if ((bt_link_info->slave_role) && (bt_link_info->a2dp_exist))
1550                 psTdmaByte4Modify = 0x1;
1551         else
1552                 psTdmaByte4Modify = 0x0;
1553
1554         if (pre_psTdmaByte4Modify != psTdmaByte4Modify) {
1555
1556                 force_exec = true;
1557                 pre_psTdmaByte4Modify = psTdmaByte4Modify;
1558         }
1559
1560         if (!force_exec) {
1561                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1562                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1563                         return;
1564         }
1565
1566         if (coex_dm->cur_ps_tdma_on) {
1567                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1568                             "[BTCoex], ********** TDMA(on, %d) **********\n",
1569                             coex_dm->cur_ps_tdma);
1570                 BTC_TRACE(trace_buf);
1571
1572                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
1573                                            0x1);  /* enable TBTT nterrupt */
1574         } else {
1575                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1576                             "[BTCoex], ********** TDMA(off, %d) **********\n",
1577                             coex_dm->cur_ps_tdma);
1578                 BTC_TRACE(trace_buf);
1579         }
1580
1581
1582         if (turn_on) {
1583                 switch (type) {
1584                 case 1:
1585                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1586                                                                 0x10, 0x03, 0x91,
1587                                                                 0x54 | psTdmaByte4Modify);
1588                         break;
1589                 case 2:
1590                 default:
1591                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1592                                                                 0x35, 0x03, 0x11,
1593                                                                 0x11 | psTdmaByte4Modify);
1594                         break;
1595                 case 3:
1596                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1597                                                                 0x3a, 0x3, 0x91,
1598                                                                 0x10 | psTdmaByte4Modify);
1599                         break;
1600                 case 4:
1601                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1602                                                                 0x21, 0x3, 0x91,
1603                                                                 0x10 | psTdmaByte4Modify);
1604                         break;
1605                 case 5:
1606                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1607                                                                 0x25, 0x3, 0x91,
1608                                                                 0x10 | psTdmaByte4Modify);
1609                         break;
1610                 case 6:
1611                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1612                                                                 0x10, 0x3, 0x91,
1613                                                                 0x10 | psTdmaByte4Modify);
1614                         break;
1615                 case 7:
1616                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1617                                                                 0x20, 0x3, 0x91,
1618                                                                 0x10 | psTdmaByte4Modify);
1619                         break;
1620                 case 8:
1621                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1622                                                                 0x15, 0x03, 0x11,
1623                                                                 0x11);
1624                         break;
1625                 case 10:
1626                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1627                                                                 0x30, 0x03, 0x11,
1628                                                                 0x10);
1629                         break;
1630                 case 11:
1631                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1632                                                                 0x35, 0x03, 0x11,
1633                                                                 0x10 | psTdmaByte4Modify);
1634                         break;
1635                 case 12:
1636                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1637                                                                 0x35, 0x03, 0x11, 0x11);
1638                         break;
1639                 case 13:
1640                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1641                                                                 0x1c, 0x03, 0x11,
1642                                                                 0x10 | psTdmaByte4Modify);
1643                         break;
1644                 case 14:
1645                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1646                                                                 0x20, 0x03, 0x11,
1647                                                                 0x11);
1648                         break;
1649                 case 15:
1650                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1651                                                                 0x10, 0x03, 0x11,
1652                                                                 0x14);
1653                         break;
1654                 case 16:
1655                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1656                                                                 0x10, 0x03, 0x11,
1657                                                                 0x15);
1658                         break;
1659                 case 21:
1660                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1661                                                                 0x30, 0x03, 0x11,
1662                                                                 0x10);
1663                         break;
1664                 case 22:
1665                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1666                                                                 0x25, 0x03, 0x11,
1667                                                                 0x10);
1668                         break;
1669                 case 23:
1670                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1671                                                                 0x10, 0x03, 0x11,
1672                                                                 0x10);
1673                         break;
1674                 case 51:
1675                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1676                                                                 0x10, 0x03, 0x91,
1677                                                                 0x10 | psTdmaByte4Modify);
1678                         break;
1679                 case 101:
1680                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1681                                                                 0x10, 0x03, 0x10,
1682                                                                 0x54 | psTdmaByte4Modify);
1683                         break;
1684                 case 102:
1685                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x61,
1686                                                                 0x35, 0x03, 0x11,
1687                                                                 0x11 | psTdmaByte4Modify);
1688                         break;
1689                 case 103:
1690                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1691                                                                 0x3a, 0x3, 0x10,
1692                                                                 0x50 | psTdmaByte4Modify);
1693                         break;
1694                 case 104:
1695                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1696                                                                 0x21, 0x3, 0x10,
1697                                                                 0x50 | psTdmaByte4Modify);
1698                         break;
1699                 case 105:
1700                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1701                                                                 0x25, 0x3, 0x10,
1702                                                                 0x50 | psTdmaByte4Modify);
1703                         break;
1704                 case 106:
1705                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1706                                                                 0x10, 0x3, 0x10,
1707                                                                 0x50 | psTdmaByte4Modify);
1708                         break;
1709                 case 107:
1710                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1711                                                                 0x20, 0x3, 0x10,
1712                                                                 0x50 | psTdmaByte4Modify);
1713                         break;
1714                 case 108:
1715                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1716                                                                 0x30, 0x3, 0x10,
1717                                                                 0x50 | psTdmaByte4Modify);
1718                         break;
1719                 case 109:
1720                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x55,
1721                                                                 0x10, 0x03, 0x10,
1722                                                                 0x54 | psTdmaByte4Modify);
1723                         break;
1724                 case 110:
1725                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x55,
1726                                                                 0x30, 0x03, 0x10,
1727                                                                 0x50 | psTdmaByte4Modify);
1728                         break;
1729                 case 111:
1730                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x65,
1731                                                                 0x25, 0x03, 0x11,
1732                                                                 0x11 | psTdmaByte4Modify);
1733                         break;
1734                 case 151:
1735                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x51,
1736                                                                 0x10, 0x03, 0x10,
1737                                                                 0x50 | psTdmaByte4Modify);
1738                         break;
1739                 }
1740         } else {
1741                 /* disable PS tdma */
1742                 switch (type) {
1743                 case 0:
1744                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1745                                                       0x0, 0x0, 0x40, 0x0);
1746                         break;
1747                 case 1:
1748                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1749                                                       0x0, 0x0, 0x48, 0x0);
1750                         break;
1751                 default:
1752                         halbtc8723d2ant_set_fw_pstdma(btcoexist, 0x0,
1753                                                       0x0, 0x0, 0x40, 0x0);
1754                         break;
1755                 }
1756         }
1757
1758         /* update pre state */
1759         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1760         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1761 }
1762
1763 void halbtc8723d2ant_set_ant_path(IN struct btc_coexist *btcoexist,
1764                                   IN u8 ant_pos_type, IN boolean force_exec,
1765                                   IN u8 phase)
1766 {
1767         struct  btc_board_info *board_info = &btcoexist->board_info;
1768         u32                     u32tmp = 0;
1769         boolean                 pg_ext_switch = false,  is_hw_ant_div_on = false;
1770         u8                      h2c_parameter[2] = {0};
1771         u32                     cnt_bt_cal_chk = 0;
1772         u8                      u8tmp0 = 0, u8tmp1 = 0;
1773         boolean                 is_in_mp_mode = false;
1774         u32                             u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
1775         u16                             u16tmp0 = 0,  u16tmp1 = 0;
1776
1777
1778         u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
1779                         0x38);
1780
1781      /* To avoid indirect access fail   */
1782         if (((u32tmp1 & 0xf000) >> 12) != ((u32tmp1 & 0x0f00) >> 8)) {
1783                 force_exec = true;
1784                 coex_sta->gnt_error_cnt++;
1785         }
1786
1787
1788 #if BT_8723D_2ANT_COEX_DBG
1789         u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
1790         u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
1791         u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1792         u8tmp1  = btcoexist->btc_read_1byte(btcoexist, 0x73);
1793         u8tmp0 =  btcoexist->btc_read_1byte(btcoexist, 0x67);
1794
1795         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1796                 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before Set Ant Pat)\n",
1797                     u8tmp0, u16tmp1, u8tmp1);
1798         BTC_TRACE(trace_buf);
1799
1800         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1801                 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa = 0x%x (Before Set Ant Path)\n",
1802                     u32tmp1, u32tmp2, u16tmp0);
1803         BTC_TRACE(trace_buf);
1804 #endif
1805
1806         coex_dm->cur_ant_pos_type = ant_pos_type;
1807
1808         if (!force_exec) {
1809                 if (coex_dm->cur_ant_pos_type == coex_dm->pre_ant_pos_type) {
1810
1811                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1812                                 "[BTCoex], ********** Skip Antenna Path Setup because no change!!**********\n");
1813                         BTC_TRACE(trace_buf);
1814                         return;
1815                 }
1816         }
1817
1818         coex_dm->pre_ant_pos_type = coex_dm->cur_ant_pos_type;
1819
1820         switch (phase) {
1821         case BT_8723D_2ANT_PHASE_COEX_POWERON:
1822                 /* Set Path control to WL */
1823                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
1824                                                    0x80, 0x0);
1825
1826                 /* set Path control owner to WL at initial step */
1827                 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
1828                                 BT_8723D_2ANT_PCO_BTSIDE);
1829
1830                 /* set GNT_BT to SW high */
1831                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1832                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1833                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1834                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1835                 /* Set GNT_WL to SW low */
1836                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1837                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1838                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1839                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1840
1841                 if (BTC_ANT_PATH_AUTO == ant_pos_type)
1842                         ant_pos_type = BTC_ANT_PATH_WIFI;
1843
1844                 coex_sta->run_time_state = false;
1845
1846                 break;
1847         case BT_8723D_2ANT_PHASE_COEX_INIT:
1848                 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
1849                 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1850
1851                 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
1852                 halbtc8723d2ant_ltecoex_set_coex_table(
1853                         btcoexist,
1854                         BT_8723D_2ANT_CTT_WL_VS_LTE,
1855                         0xffff);
1856
1857                 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
1858                 halbtc8723d2ant_ltecoex_set_coex_table(
1859                         btcoexist,
1860                         BT_8723D_2ANT_CTT_BT_VS_LTE,
1861                         0xffff);
1862
1863                 /* Wait If BT IQK running, because Path control owner is at BT during BT IQK (setup by WiFi firmware) */
1864                 while (cnt_bt_cal_chk <= 20) {
1865                         u8tmp0 = btcoexist->btc_read_1byte(
1866                                          btcoexist,
1867                                          0x49d);
1868                         cnt_bt_cal_chk++;
1869                         if (u8tmp0 & BIT(0)) {
1870                                 BTC_SPRINTF(
1871                                         trace_buf,
1872                                         BT_TMP_BUF_SIZE,
1873                                         "[BTCoex], ########### BT is calibrating (wait cnt=%d) ###########\n",
1874                                         cnt_bt_cal_chk);
1875                                 BTC_TRACE(
1876                                         trace_buf);
1877                                 delay_ms(50);
1878                         } else {
1879                                 BTC_SPRINTF(
1880                                         trace_buf,
1881                                         BT_TMP_BUF_SIZE,
1882                                         "[BTCoex], ********** BT is NOT calibrating (wait cnt=%d)**********\n",
1883                                         cnt_bt_cal_chk);
1884                                 BTC_TRACE(
1885                                         trace_buf);
1886                                 break;
1887                         }
1888                 }
1889
1890
1891                 /* Set Path control to WL */
1892                 btcoexist->btc_write_1byte_bitmask(btcoexist,
1893                                                    0x67, 0x80, 0x1);
1894
1895                 /* set Path control owner to WL at initial step */
1896                 halbtc8723d2ant_ltecoex_pathcontrol_owner(
1897                         btcoexist,
1898                         BT_8723D_2ANT_PCO_WLSIDE);
1899
1900                 /* set GNT_BT to SW high */
1901                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1902                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1903                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1904                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1905                 /* Set GNT_WL to SW high */
1906                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1907                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1908                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1909                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1910
1911                 coex_sta->run_time_state = false;
1912
1913                 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
1914                         if (board_info->btdm_ant_pos ==
1915                             BTC_ANTENNA_AT_MAIN_PORT)
1916                                 ant_pos_type =
1917                                         BTC_ANT_WIFI_AT_MAIN;
1918                         else
1919                                 ant_pos_type =
1920                                         BTC_ANT_WIFI_AT_AUX;
1921                 }
1922
1923                 break;
1924         case BT_8723D_2ANT_PHASE_WLANONLY_INIT:
1925                 /* Disable LTE Coex Function in WiFi side (this should be on if LTE coex is required) */
1926                 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1927
1928                 /* GNT_WL_LTE always = 1 (this should be config if LTE coex is required) */
1929                 halbtc8723d2ant_ltecoex_set_coex_table(
1930                         btcoexist,
1931                         BT_8723D_2ANT_CTT_WL_VS_LTE,
1932                         0xffff);
1933
1934                 /* GNT_BT_LTE always = 1 (this should be config if LTE coex is required) */
1935                 halbtc8723d2ant_ltecoex_set_coex_table(
1936                         btcoexist,
1937                         BT_8723D_2ANT_CTT_BT_VS_LTE,
1938                         0xffff);
1939
1940                 /* Set Path control to WL */
1941                 btcoexist->btc_write_1byte_bitmask(btcoexist,
1942                                                    0x67, 0x80, 0x1);
1943
1944                 /* set Path control owner to WL at initial step */
1945                 halbtc8723d2ant_ltecoex_pathcontrol_owner(
1946                         btcoexist,
1947                         BT_8723D_2ANT_PCO_WLSIDE);
1948
1949                 /* set GNT_BT to SW Low */
1950                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
1951                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1952                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1953                                            BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
1954                 /* Set GNT_WL to SW high */
1955                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
1956                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
1957                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
1958                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
1959
1960                 coex_sta->run_time_state = false;
1961
1962                 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
1963                         if (board_info->btdm_ant_pos ==
1964                             BTC_ANTENNA_AT_MAIN_PORT)
1965                                 ant_pos_type =
1966                                         BTC_ANT_WIFI_AT_MAIN;
1967                         else
1968                                 ant_pos_type =
1969                                         BTC_ANT_WIFI_AT_AUX;
1970                 }
1971
1972                 break;
1973         case BT_8723D_2ANT_PHASE_WLAN_OFF:
1974                 /* Disable LTE Coex Function in WiFi side */
1975                 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
1976
1977                 /* Set Path control to BT */
1978                 btcoexist->btc_write_1byte_bitmask(btcoexist,
1979                                                    0x67, 0x80, 0x0);
1980
1981                 /* set Path control owner to BT */
1982                 halbtc8723d2ant_ltecoex_pathcontrol_owner(
1983                         btcoexist,
1984                         BT_8723D_2ANT_PCO_BTSIDE);
1985
1986                 coex_sta->run_time_state = false;
1987                 break;
1988         case BT_8723D_2ANT_PHASE_2G_RUNTIME:
1989
1990                 /* wait for WL/BT IQK finish, keep 0x38 = 0xff00 for WL IQK */
1991                 while (cnt_bt_cal_chk <= 20) {
1992                         u8tmp0 = btcoexist->btc_read_1byte(
1993                                          btcoexist,
1994                                          0x1e6);
1995
1996                         u8tmp1 = btcoexist->btc_read_1byte(
1997                                          btcoexist,
1998                                          0x49d);
1999
2000                         cnt_bt_cal_chk++;
2001                         if ((u8tmp0 & BIT(0)) ||
2002                             (u8tmp1 & BIT(0))) {
2003                                 BTC_SPRINTF(trace_buf,
2004                                             BT_TMP_BUF_SIZE,
2005                                         "[BTCoex], ########### WL or BT is IQK (wait cnt=%d)\n",
2006                                             cnt_bt_cal_chk);
2007                                 BTC_TRACE(trace_buf);
2008                                 delay_ms(50);
2009                         } else {
2010                                 BTC_SPRINTF(trace_buf,
2011                                             BT_TMP_BUF_SIZE,
2012                                         "[BTCoex], ********** WL and BT is NOT IQK (wait cnt=%d)\n",
2013                                             cnt_bt_cal_chk);
2014                                 BTC_TRACE(trace_buf);
2015                                 break;
2016                         }
2017                 }
2018
2019                 /* Set Path control to WL */
2020                 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);*/
2021
2022                 /* set Path control owner to WL at runtime step */
2023                 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2024                         btcoexist,
2025                         BT_8723D_2ANT_PCO_WLSIDE);
2026
2027
2028                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2029                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2030                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2031                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2032
2033                 /* Set GNT_WL to PTA */
2034                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2035                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2036                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_PTA,
2037                                            BT_8723D_2ANT_SIG_STA_SET_BY_HW);
2038
2039                 coex_sta->run_time_state = true;
2040
2041                 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2042                         if (board_info->btdm_ant_pos ==
2043                             BTC_ANTENNA_AT_MAIN_PORT)
2044                                 ant_pos_type =
2045                                         BTC_ANT_WIFI_AT_MAIN;
2046                         else
2047                                 ant_pos_type =
2048                                         BTC_ANT_WIFI_AT_AUX;
2049                 }
2050
2051                 break;
2052         case BT_8723D_2ANT_PHASE_BTMPMODE:
2053                 /* Disable LTE Coex Function in WiFi side */
2054                 halbtc8723d2ant_ltecoex_enable(btcoexist, 0x0);
2055
2056                 /* Set Path control to WL */
2057                 btcoexist->btc_write_1byte_bitmask(btcoexist,
2058                                                    0x67, 0x80, 0x1);
2059
2060                 /* set Path control owner to WL */
2061                 halbtc8723d2ant_ltecoex_pathcontrol_owner(
2062                         btcoexist,
2063                         BT_8723D_2ANT_PCO_WLSIDE);
2064
2065                 /* set GNT_BT to SW Hi */
2066                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2067                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2068                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2069                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2070
2071                 /* Set GNT_WL to SW Lo */
2072                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2073                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2074                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2075                                            BT_8723D_2ANT_SIG_STA_SET_TO_LOW);
2076
2077                 coex_sta->run_time_state = false;
2078
2079                 if (BTC_ANT_PATH_AUTO == ant_pos_type) {
2080                         if (board_info->btdm_ant_pos ==
2081                             BTC_ANTENNA_AT_MAIN_PORT)
2082                                 ant_pos_type =
2083                                         BTC_ANT_WIFI_AT_MAIN;
2084                         else
2085                                 ant_pos_type =
2086                                         BTC_ANT_WIFI_AT_AUX;
2087                 }
2088
2089                 break;
2090         case BT_8723D_2ANT_PHASE_ANTENNA_DET:
2091
2092                 /* Set Path control to WL */
2093                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67,
2094                                                    0x80, 0x1);
2095
2096                 /* set Path control owner to WL */
2097                 halbtc8723d2ant_ltecoex_pathcontrol_owner(btcoexist,
2098                                 BT_8723D_2ANT_PCO_WLSIDE);
2099
2100                 /* Set Antenna Path,  both GNT_WL/GNT_BT = 1, and control by SW */
2101                 /* set GNT_BT to SW high */
2102                 halbtc8723d2ant_ltecoex_set_gnt_bt(btcoexist,
2103                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2104                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2105                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2106
2107                 /* Set GNT_WL to SW high */
2108                 halbtc8723d2ant_ltecoex_set_gnt_wl(btcoexist,
2109                                            BT_8723D_2ANT_GNT_BLOCK_RFC_BB,
2110                                            BT_8723D_2ANT_GNT_TYPE_CTRL_BY_SW,
2111                                            BT_8723D_2ANT_SIG_STA_SET_TO_HIGH);
2112
2113                 if (BTC_ANT_PATH_AUTO == ant_pos_type)
2114                         ant_pos_type = BTC_ANT_WIFI_AT_AUX;
2115
2116                 coex_sta->run_time_state = false;
2117
2118                 break;
2119         }
2120
2121         is_hw_ant_div_on = board_info->ant_div_cfg;
2122
2123         if ((is_hw_ant_div_on) && (phase != BT_8723D_2ANT_PHASE_ANTENNA_DET))
2124                 btcoexist->btc_write_2byte(btcoexist, 0x948, 0x140);
2125         else if ((is_hw_ant_div_on == false) &&
2126                  (phase != BT_8723D_2ANT_PHASE_WLAN_OFF)) {
2127
2128                 switch (ant_pos_type) {
2129                 case BTC_ANT_WIFI_AT_MAIN:
2130
2131                         btcoexist->btc_write_2byte(btcoexist,
2132                                                    0x948, 0x0);
2133                         break;
2134                 case BTC_ANT_WIFI_AT_AUX:
2135
2136                         btcoexist->btc_write_2byte(btcoexist,
2137                                                    0x948, 0x280);
2138                         break;
2139                 }
2140         }
2141
2142
2143 #if BT_8723D_2ANT_COEX_DBG
2144         u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
2145         u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
2146         u16tmp0 = btcoexist->btc_read_2byte(btcoexist, 0xaa);
2147         u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
2148         u8tmp1  = btcoexist->btc_read_1byte(btcoexist, 0x73);
2149         u8tmp0 =  btcoexist->btc_read_1byte(btcoexist, 0x67);
2150
2151         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2152                 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(After Set Ant Pat)\n",
2153                     u8tmp0, u16tmp1, u8tmp1);
2154         BTC_TRACE(trace_buf);
2155
2156         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2157                 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x, 0xaa= 0x%x (After Set Ant Path)\n",
2158                     u32tmp1, u32tmp2, u16tmp0);
2159         BTC_TRACE(trace_buf);
2160 #endif
2161
2162 }
2163
2164 u8 halbtc8723d2ant_action_algorithm(IN struct btc_coexist *btcoexist)
2165 {
2166         struct  btc_bt_link_info        *bt_link_info = &btcoexist->bt_link_info;
2167         boolean                         bt_hs_on = false;
2168         u8                              algorithm = BT_8723D_2ANT_COEX_ALGO_UNDEFINED;
2169         u8                              num_of_diff_profile = 0;
2170
2171         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2172
2173         if (!bt_link_info->bt_link_exist) {
2174                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2175                             "[BTCoex], No BT link exists!!!\n");
2176                 BTC_TRACE(trace_buf);
2177                 return algorithm;
2178         }
2179
2180         if (bt_link_info->sco_exist)
2181                 num_of_diff_profile++;
2182         if (bt_link_info->hid_exist)
2183                 num_of_diff_profile++;
2184         if (bt_link_info->pan_exist)
2185                 num_of_diff_profile++;
2186         if (bt_link_info->a2dp_exist)
2187                 num_of_diff_profile++;
2188
2189         if (num_of_diff_profile == 0) {
2190
2191                 if (bt_link_info->acl_busy) {
2192                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2193                                     "[BTCoex], No-Profile busy\n");
2194                         BTC_TRACE(trace_buf);
2195                         algorithm = BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY;
2196                 }
2197         } else if (num_of_diff_profile == 1) {
2198                 if (bt_link_info->sco_exist) {
2199                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2200                                     "[BTCoex], SCO only\n");
2201                         BTC_TRACE(trace_buf);
2202                         algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2203                 } else {
2204                         if (bt_link_info->hid_exist) {
2205                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2206                                             "[BTCoex], HID only\n");
2207                                 BTC_TRACE(trace_buf);
2208                                 algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2209                         } else if (bt_link_info->a2dp_exist) {
2210                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2211                                             "[BTCoex], A2DP only\n");
2212                                 BTC_TRACE(trace_buf);
2213                                 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2214                         } else if (bt_link_info->pan_exist) {
2215                                 if (bt_hs_on) {
2216                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2217                                                     "[BTCoex], PAN(HS) only\n");
2218                                         BTC_TRACE(trace_buf);
2219                                         algorithm =
2220                                                 BT_8723D_2ANT_COEX_ALGO_PANHS;
2221                                 } else {
2222                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2223                                                 "[BTCoex], PAN(EDR) only\n");
2224                                         BTC_TRACE(trace_buf);
2225                                         algorithm =
2226                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2227                                 }
2228                         }
2229                 }
2230         } else if (num_of_diff_profile == 2) {
2231                 if (bt_link_info->sco_exist) {
2232                         if (bt_link_info->hid_exist) {
2233                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2234                                             "[BTCoex], SCO + HID\n");
2235                                 BTC_TRACE(trace_buf);
2236                                 algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2237                         } else if (bt_link_info->a2dp_exist) {
2238                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2239                                             "[BTCoex], SCO + A2DP ==> A2DP\n");
2240                                 BTC_TRACE(trace_buf);
2241                                 algorithm = BT_8723D_2ANT_COEX_ALGO_A2DP;
2242                         } else if (bt_link_info->pan_exist) {
2243                                 if (bt_hs_on) {
2244                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2245                                                 "[BTCoex], SCO + PAN(HS)\n");
2246                                         BTC_TRACE(trace_buf);
2247                                         algorithm = BT_8723D_2ANT_COEX_ALGO_SCO;
2248                                 } else {
2249                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2250                                                 "[BTCoex], SCO + PAN(EDR)\n");
2251                                         BTC_TRACE(trace_buf);
2252                                         algorithm =
2253                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR;
2254                                 }
2255                         }
2256                 } else {
2257                         if (bt_link_info->hid_exist &&
2258                             bt_link_info->a2dp_exist) {
2259                                 {
2260                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2261                                                     "[BTCoex], HID + A2DP\n");
2262                                         BTC_TRACE(trace_buf);
2263                                         algorithm =
2264                                                 BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2265                                 }
2266                         } else if (bt_link_info->hid_exist &&
2267                                    bt_link_info->pan_exist) {
2268                                 if (bt_hs_on) {
2269                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2270                                                 "[BTCoex], HID + PAN(HS)\n");
2271                                         BTC_TRACE(trace_buf);
2272                                         algorithm = BT_8723D_2ANT_COEX_ALGO_HID;
2273                                 } else {
2274                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2275                                                 "[BTCoex], HID + PAN(EDR)\n");
2276                                         BTC_TRACE(trace_buf);
2277                                         algorithm =
2278                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2279                                 }
2280                         } else if (bt_link_info->pan_exist &&
2281                                    bt_link_info->a2dp_exist) {
2282                                 if (bt_hs_on) {
2283                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2284                                                 "[BTCoex], A2DP + PAN(HS)\n");
2285                                         BTC_TRACE(trace_buf);
2286                                         algorithm =
2287                                                 BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS;
2288                                 } else {
2289                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2290                                                 "[BTCoex], A2DP + PAN(EDR)\n");
2291                                         BTC_TRACE(trace_buf);
2292                                         algorithm =
2293                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2294                                 }
2295                         }
2296                 }
2297         } else if (num_of_diff_profile == 3) {
2298                 if (bt_link_info->sco_exist) {
2299                         if (bt_link_info->hid_exist &&
2300                             bt_link_info->a2dp_exist) {
2301                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2302                                         "[BTCoex], SCO + HID + A2DP ==> HID + A2DP\n");
2303                                 BTC_TRACE(trace_buf);
2304                                 algorithm = BT_8723D_2ANT_COEX_ALGO_HID_A2DP;
2305                         } else if (bt_link_info->hid_exist &&
2306                                    bt_link_info->pan_exist) {
2307                                 if (bt_hs_on) {
2308                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2309                                                 "[BTCoex], SCO + HID + PAN(HS)\n");
2310                                         BTC_TRACE(trace_buf);
2311                                         algorithm =
2312                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2313                                 } else {
2314                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2315                                                 "[BTCoex], SCO + HID + PAN(EDR)\n");
2316                                         BTC_TRACE(trace_buf);
2317                                         algorithm =
2318                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_HID;
2319                                 }
2320                         } else if (bt_link_info->pan_exist &&
2321                                    bt_link_info->a2dp_exist) {
2322                                 if (bt_hs_on) {
2323                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2324                                                 "[BTCoex], SCO + A2DP + PAN(HS)\n");
2325                                         BTC_TRACE(trace_buf);
2326                                         algorithm =
2327                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2328                                 } else {
2329                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2330                                                 "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
2331                                         BTC_TRACE(trace_buf);
2332                                         algorithm =
2333                                                 BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP;
2334                                 }
2335                         }
2336                 } else {
2337                         if (bt_link_info->hid_exist &&
2338                             bt_link_info->pan_exist &&
2339                             bt_link_info->a2dp_exist) {
2340                                 if (bt_hs_on) {
2341                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2342                                                 "[BTCoex], HID + A2DP + PAN(HS)\n");
2343                                         BTC_TRACE(trace_buf);
2344                                         algorithm =
2345                                                 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2346                                 } else {
2347                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2348                                                 "[BTCoex], HID + A2DP + PAN(EDR)\n");
2349                                         BTC_TRACE(trace_buf);
2350                                         algorithm =
2351                                                 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2352                                 }
2353                         }
2354                 }
2355         } else if (num_of_diff_profile >= 3) {
2356                 if (bt_link_info->sco_exist) {
2357                         if (bt_link_info->hid_exist &&
2358                             bt_link_info->pan_exist &&
2359                             bt_link_info->a2dp_exist) {
2360                                 if (bt_hs_on) {
2361                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2362                                                 "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
2363                                         BTC_TRACE(trace_buf);
2364                                         algorithm =
2365                                                 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2366                                 } else {
2367                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2368                                                 "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
2369                                         BTC_TRACE(trace_buf);
2370                                         algorithm =
2371                                                 BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
2372                                 }
2373                         }
2374                 }
2375         }
2376
2377         return algorithm;
2378 }
2379
2380
2381
2382 void halbtc8723d2ant_action_coex_all_off(IN struct btc_coexist *btcoexist)
2383 {
2384
2385         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2386
2387         /* fw all off */
2388         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2389
2390         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2391         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2392 }
2393
2394 void halbtc8723d2ant_action_bt_whql_test(IN struct btc_coexist *btcoexist)
2395 {
2396         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2397         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2398
2399         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2400
2401         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2402 }
2403
2404 void halbtc8723d2ant_action_bt_hs(IN struct btc_coexist *btcoexist)
2405 {
2406         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2407         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2408         u8              wifi_rssi_state, bt_rssi_state;
2409
2410         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2411         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2412         u8              wifi_rssi_state2, bt_rssi_state2;
2413         boolean wifi_busy = false, wifi_turbo = false;
2414
2415
2416         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2417         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2418                            &coex_sta->scan_ap_num);
2419         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2420                         "############# [BTCoex],  scan_ap_num = %d, wl_noisy = %d\n",
2421                         coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2422         BTC_TRACE(trace_buf);
2423
2424 #if 1
2425         if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2426                 wifi_turbo = true;
2427 #endif
2428
2429
2430         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2431                           &prewifi_rssi_state, 2,
2432                           coex_sta->wifi_coex_thres , 0);
2433
2434         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2435                            &prewifi_rssi_state2, 2,
2436                            coex_sta->wifi_coex_thres2 , 0);
2437
2438         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2439                         coex_sta->bt_coex_thres , 0);
2440
2441         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2442                          coex_sta->bt_coex_thres2 , 0);
2443
2444         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2445                 BTC_RSSI_HIGH(bt_rssi_state)) {
2446
2447                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2448                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2449
2450                 coex_dm->is_switch_to_1dot5_ant = false;
2451
2452                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2453
2454                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2455         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2456                    BTC_RSSI_HIGH(bt_rssi_state2)) {
2457
2458                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2459                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2460
2461                 coex_dm->is_switch_to_1dot5_ant = false;
2462
2463                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2464
2465                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2466
2467
2468         } else {
2469
2470                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2471                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2472
2473                 coex_dm->is_switch_to_1dot5_ant = true;
2474
2475                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2476
2477                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2478         }
2479
2480 }
2481
2482
2483 void halbtc8723d2ant_action_bt_inquiry(IN struct btc_coexist *btcoexist)
2484 {
2485
2486         boolean wifi_connected = false;
2487         boolean wifi_scan = false, wifi_link = false, wifi_roam = false;
2488         boolean wifi_busy = false;
2489         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2490
2491
2492         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2493
2494         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2495                            &wifi_connected);
2496
2497         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
2498         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
2499         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
2500
2501         if ((coex_sta->bt_create_connection) && ((wifi_link) || (wifi_roam)
2502                 || (wifi_scan) || (wifi_busy) || (coex_sta->wifi_is_high_pri_task))) {
2503
2504                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2505                         "[BTCoex], Wifi link/roam/Scan/busy/hi-pri-task + BT Inq/Page!!\n");
2506                 BTC_TRACE(trace_buf);
2507
2508                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2509                                                          8);
2510
2511                 if ((bt_link_info->a2dp_exist) && (!bt_link_info->pan_exist))
2512                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2513                                                 15);
2514                 else
2515                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2516                                                 11);
2517         }  else if ((!wifi_connected) && (!wifi_scan)) {
2518
2519                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2520                                 "[BTCoex], Wifi no-link + no-scan + BT Inq/Page!!\n");
2521                 BTC_TRACE(trace_buf);
2522
2523                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2524
2525                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2526         } else if (bt_link_info->pan_exist) {
2527
2528                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
2529
2530                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2531
2532         } else if (bt_link_info->a2dp_exist) {
2533
2534                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
2535
2536                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2537         } else {
2538
2539                 if ((wifi_link) || (wifi_roam) || (wifi_scan) || (wifi_busy)
2540                         || (coex_sta->wifi_is_high_pri_task))
2541                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 21);
2542                 else
2543                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 23);
2544
2545                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
2546         }
2547
2548         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2549         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2550 }
2551
2552
2553 void halbtc8723d2ant_action_bt_relink(IN struct btc_coexist *btcoexist)
2554 {
2555         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
2556         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
2557
2558         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2559         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2560         coex_sta->bt_relink_downcount = 2;
2561 }
2562
2563 void halbtc8723d2ant_action_bt_idle(IN struct btc_coexist *btcoexist)
2564 {
2565         boolean wifi_busy = false;
2566
2567         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2568
2569         if (!wifi_busy) {
2570
2571                 halbtc8723d2ant_coex_table_with_type(btcoexist,
2572                                                                  NORMAL_EXEC, 2);
2573
2574                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2575         } else {  /* if wl busy */
2576
2577                 if (BT_8723D_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2578                         coex_dm->bt_status) {
2579
2580                         halbtc8723d2ant_coex_table_with_type(btcoexist,
2581                                                                  NORMAL_EXEC, 0);
2582
2583                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2584            } else {
2585
2586                         halbtc8723d2ant_coex_table_with_type(btcoexist,
2587                                                                         NORMAL_EXEC, 8);
2588                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2589                                                         12);
2590                 }
2591         }
2592
2593         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
2594         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2595
2596 }
2597
2598
2599
2600 /* SCO only or SCO+PAN(HS) */
2601 void halbtc8723d2ant_action_sco(IN struct btc_coexist *btcoexist)
2602 {
2603         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2604         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2605         u8      wifi_rssi_state, bt_rssi_state;
2606
2607         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2608         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2609         u8      wifi_rssi_state2, bt_rssi_state2;
2610         boolean wifi_busy = false;
2611         u32  wifi_bw = 1;
2612
2613         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2614                            &wifi_bw);
2615
2616         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2617
2618         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2619                           &prewifi_rssi_state, 2,
2620                           coex_sta->wifi_coex_thres , 0);
2621
2622         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2623                            &prewifi_rssi_state2, 2,
2624                            coex_sta->wifi_coex_thres2 , 0);
2625
2626         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2627                         coex_sta->bt_coex_thres , 0);
2628
2629         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2630                          coex_sta->bt_coex_thres2 , 0);
2631
2632
2633         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2634                 BTC_RSSI_HIGH(bt_rssi_state)) {
2635
2636                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2637                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2638
2639                 coex_dm->is_switch_to_1dot5_ant = false;
2640
2641                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2642
2643                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2644         }  else {
2645
2646                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2647                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2648
2649                 coex_dm->is_switch_to_1dot5_ant = false;
2650
2651                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2652                                                                  1);
2653                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
2654         }
2655
2656 }
2657
2658
2659 void halbtc8723d2ant_action_hid(IN struct btc_coexist *btcoexist)
2660 {
2661         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2662         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2663         u8              wifi_rssi_state, bt_rssi_state;
2664
2665         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2666         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2667         u8              wifi_rssi_state2, bt_rssi_state2;
2668         boolean wifi_busy = false;
2669         u32  wifi_bw = 1;
2670
2671
2672         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2673         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,  &wifi_bw);
2674
2675         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2676                           &prewifi_rssi_state, 2,
2677                           coex_sta->wifi_coex_thres , 0);
2678
2679         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2680                            &prewifi_rssi_state2, 2,
2681                            coex_sta->wifi_coex_thres2 , 0);
2682
2683         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2684                         coex_sta->bt_coex_thres , 0);
2685
2686         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2687                          coex_sta->bt_coex_thres2 , 0);
2688
2689
2690         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2691                 BTC_RSSI_HIGH(bt_rssi_state)) {
2692
2693                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2694                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2695
2696                 coex_dm->is_switch_to_1dot5_ant = false;
2697
2698                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2699
2700                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2701         }  else {
2702
2703                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2704                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2705
2706                 coex_dm->is_switch_to_1dot5_ant = false;
2707
2708                 /*for 4/18 hid */
2709                 if (coex_sta->hid_busy_num >= 2) {
2710                         if (wifi_bw == 0) {   /* if 11bg mode */
2711
2712                                  halbtc8723d2ant_coex_table_with_type(btcoexist,
2713                                                                  NORMAL_EXEC, 8);
2714                                  halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
2715                                                                 NORMAL_EXEC,
2716                                                                 0x1, 0xaa,
2717                                                                 0x5a, 0xaa,
2718                                                                 0xaa);
2719                                  halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2720                                                         111);
2721                         } else {
2722
2723                           if (wifi_busy) {
2724                                           halbtc8723d2ant_coex_table_with_type(btcoexist,
2725                                                                          NORMAL_EXEC, 8);
2726                                           halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
2727                                                                          NORMAL_EXEC,
2728                                                                          0x2, 0xaa,
2729                                                                          0x5a, 0xaa,
2730                                                                          0xaa);
2731                                           halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2732                                                                          111);
2733                                 } else {
2734
2735                                           halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2736                                                                  3);
2737                                           halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2738                                 }
2739                         }
2740                 } else {
2741
2742                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2743                                                                  3);
2744                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
2745                 }
2746         }
2747
2748 }
2749
2750
2751 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2752 void halbtc8723d2ant_action_a2dp(IN struct btc_coexist *btcoexist)
2753 {
2754         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2755         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2756         u8              wifi_rssi_state, bt_rssi_state;
2757
2758         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2759         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2760         u8              wifi_rssi_state2, bt_rssi_state2;
2761         boolean wifi_busy = false, wifi_turbo = false;
2762
2763
2764         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2765         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2766                            &coex_sta->scan_ap_num);
2767         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2768                         "############# [BTCoex],  scan_ap_num = %d, wl_noisy = %d\n",
2769                         coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2770         BTC_TRACE(trace_buf);
2771
2772 #if 1
2773         if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2774                 wifi_turbo = true;
2775 #endif
2776
2777         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2778                           &prewifi_rssi_state, 2,
2779                           coex_sta->wifi_coex_thres , 0);
2780
2781         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2782                            &prewifi_rssi_state2, 2,
2783                            coex_sta->wifi_coex_thres2 , 0);
2784
2785         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2786                         coex_sta->bt_coex_thres , 0);
2787
2788         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2789                          coex_sta->bt_coex_thres2 , 0);
2790
2791
2792         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2793                 BTC_RSSI_HIGH(bt_rssi_state)) {
2794
2795                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2796                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2797
2798                 coex_dm->is_switch_to_1dot5_ant = false;
2799
2800                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2801
2802                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2803         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2804                    BTC_RSSI_HIGH(bt_rssi_state2)) {
2805
2806                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2807                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2808
2809                 coex_dm->is_switch_to_1dot5_ant = false;
2810
2811                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2812
2813                 if (wifi_busy)
2814                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2815                                                         true, 1);
2816                 else
2817                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2818                                                 2);
2819         } else {
2820
2821                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2822                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2823
2824                 coex_dm->is_switch_to_1dot5_ant = true;
2825
2826                 if ((coex_sta->bt_relink_downcount != 0)
2827                         && (wifi_busy)) {
2828
2829                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2830                                 "############# [BTCoex],  BT Re-Link + A2DP + WL busy\n");
2831                         BTC_TRACE(trace_buf);
2832
2833                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2834                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
2835
2836                 } else {
2837
2838                         if (wifi_turbo)
2839                                 halbtc8723d2ant_coex_table_with_type(btcoexist,
2840                                                                          NORMAL_EXEC, 6);
2841                         else
2842                                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2843                                                                          7);
2844
2845                         if (wifi_busy)
2846                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2847                                                                 true, 101);
2848                         else
2849                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2850                                                         102);
2851                 }
2852
2853         }
2854
2855 }
2856
2857
2858 void halbtc8723d2ant_action_pan_edr(IN struct btc_coexist *btcoexist)
2859 {
2860         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2861         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2862         u8              wifi_rssi_state, bt_rssi_state;
2863
2864         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2865         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2866         u8              wifi_rssi_state2, bt_rssi_state2;
2867         boolean wifi_busy = false, wifi_turbo = false;
2868
2869
2870         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2871         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
2872                            &coex_sta->scan_ap_num);
2873         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2874                         "############# [BTCoex],  scan_ap_num = %d, wl_noisy = %d\n",
2875                         coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
2876         BTC_TRACE(trace_buf);
2877
2878 #if 1
2879         if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
2880                 wifi_turbo = true;
2881 #endif
2882
2883         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2884                           &prewifi_rssi_state, 2,
2885                           coex_sta->wifi_coex_thres , 0);
2886
2887         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2888                            &prewifi_rssi_state2, 2,
2889                            coex_sta->wifi_coex_thres2 , 0);
2890
2891         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2892                         coex_sta->bt_coex_thres , 0);
2893
2894         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2895                          coex_sta->bt_coex_thres2 , 0);
2896
2897 #if 0
2898         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2899         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2900
2901         coex_dm->is_switch_to_1dot5_ant = false;
2902
2903         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2904
2905         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2906 #endif
2907
2908
2909 #if 1
2910         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2911                 BTC_RSSI_HIGH(bt_rssi_state)) {
2912
2913                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2914                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2915
2916                 coex_dm->is_switch_to_1dot5_ant = false;
2917
2918                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
2919
2920                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2921         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
2922                    BTC_RSSI_HIGH(bt_rssi_state2)) {
2923
2924                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2925                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
2926
2927                 coex_dm->is_switch_to_1dot5_ant = false;
2928
2929                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
2930
2931                 if (wifi_busy)
2932                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2933                                                 3);
2934                 else
2935                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2936                                                 4);
2937         } else {
2938
2939                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2940                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
2941
2942                 coex_dm->is_switch_to_1dot5_ant = true;
2943
2944                 if (wifi_turbo)
2945                         halbtc8723d2ant_coex_table_with_type(btcoexist,
2946                                                                  NORMAL_EXEC, 6);
2947                 else
2948                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
2949                                                                  7);
2950
2951                 if (wifi_busy)
2952                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2953                                                 103);
2954                 else
2955                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2956                                                 104);
2957
2958         }
2959
2960 #endif
2961
2962 }
2963
2964 void halbtc8723d2ant_action_hid_a2dp(IN struct btc_coexist *btcoexist)
2965 {
2966         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2967         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
2968         u8              wifi_rssi_state, bt_rssi_state;
2969
2970         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
2971         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
2972         u8              wifi_rssi_state2, bt_rssi_state2;
2973         boolean wifi_busy = false;
2974         u32 wifi_bw = 1;
2975
2976         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2977                            &wifi_bw);
2978         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2979
2980         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2981                           &prewifi_rssi_state, 2,
2982                           coex_sta->wifi_coex_thres , 0);
2983
2984         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
2985                            &prewifi_rssi_state2, 2,
2986                            coex_sta->wifi_coex_thres2 , 0);
2987
2988         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
2989                         coex_sta->bt_coex_thres , 0);
2990
2991         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
2992                          coex_sta->bt_coex_thres2 , 0);
2993
2994
2995         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
2996                 BTC_RSSI_HIGH(bt_rssi_state)) {
2997
2998                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
2999                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3000
3001                 coex_dm->is_switch_to_1dot5_ant = false;
3002
3003                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3004                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3005         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3006                    BTC_RSSI_HIGH(bt_rssi_state2)) {
3007
3008                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3009                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3010
3011                 coex_dm->is_switch_to_1dot5_ant = false;
3012
3013                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3014
3015                 if (wifi_busy)
3016                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3017                                                         true, 1);
3018                 else
3019                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3020                                                 2);
3021         } else {
3022
3023                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3024                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3025
3026                 coex_dm->is_switch_to_1dot5_ant = true;
3027
3028                 if ((coex_sta->bt_relink_downcount != 0)
3029                         && (wifi_busy)) {
3030
3031                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3032                                 "############# [BTCoex],  BT Re-Link + A2DP + WL busy\n");
3033                         BTC_TRACE(trace_buf);
3034
3035                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3036                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 5);
3037                 } else if (wifi_busy) {
3038                         if (coex_sta->hid_busy_num >= 2) {
3039                                 halbtc8723d2ant_coex_table_with_type(btcoexist,
3040                                                                  NORMAL_EXEC, 8);
3041                                 if (wifi_bw == 0)  /*11bg mode */
3042                                         halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3043                                                                 NORMAL_EXEC,
3044                                                                 0x1, 0xaa,
3045                                                                 0x5a, 0xaa,
3046                                                                 0xaa);
3047                                 else
3048                                         halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3049                                                                 NORMAL_EXEC,
3050                                                                 0x2, 0xaa,
3051                                                                 0x5a, 0xaa,
3052                                                                 0xaa);
3053                                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3054                                                         109);
3055                         } else {
3056                                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3057                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3058                                                         true, 101);
3059                         }
3060                 } else {
3061                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3062                                                                  1);
3063                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3064                                                 102);
3065                 }
3066
3067         }
3068
3069 }
3070
3071
3072 void halbtc8723d2ant_action_a2dp_pan_hs(IN struct btc_coexist *btcoexist)
3073 {
3074         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3075         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3076         u8              wifi_rssi_state, bt_rssi_state;
3077
3078         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3079         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3080         u8              wifi_rssi_state2, bt_rssi_state2;
3081         boolean wifi_busy = false, wifi_turbo = false;
3082
3083
3084         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3085         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3086                            &coex_sta->scan_ap_num);
3087         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3088                         "############# [BTCoex],  scan_ap_num = %d, wl_noisy = %d\n",
3089                         coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3090         BTC_TRACE(trace_buf);
3091
3092 #if 1
3093         if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3094                 wifi_turbo = true;
3095 #endif
3096
3097
3098         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3099                           &prewifi_rssi_state, 2,
3100                           coex_sta->wifi_coex_thres , 0);
3101
3102         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3103                            &prewifi_rssi_state2, 2,
3104                            coex_sta->wifi_coex_thres2 , 0);
3105
3106         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3107                         coex_sta->bt_coex_thres , 0);
3108
3109         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3110                          coex_sta->bt_coex_thres2 , 0);
3111
3112
3113         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3114                 BTC_RSSI_HIGH(bt_rssi_state)) {
3115
3116                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3117                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3118
3119                 coex_dm->is_switch_to_1dot5_ant = false;
3120
3121                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3122
3123                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3124         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3125                    BTC_RSSI_HIGH(bt_rssi_state2)) {
3126
3127                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3128                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3129
3130                 coex_dm->is_switch_to_1dot5_ant = false;
3131
3132                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3133
3134                 if (wifi_busy) {
3135
3136                         if ((coex_sta->a2dp_bit_pool > 40) &&
3137                                 (coex_sta->a2dp_bit_pool < 255))
3138                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3139                                                         true, 7);
3140                         else
3141                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3142                                                         true, 5);
3143                 } else
3144                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3145                                                 6);
3146
3147         } else {
3148
3149                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3150                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3151
3152                 coex_dm->is_switch_to_1dot5_ant = true;
3153
3154                 if (wifi_turbo)
3155                         halbtc8723d2ant_coex_table_with_type(btcoexist,
3156                                                                  NORMAL_EXEC, 6);
3157                 else
3158                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3159                                                                  7);
3160
3161                 if (wifi_busy) {
3162
3163                         if ((coex_sta->a2dp_bit_pool > 40) &&
3164                                 (coex_sta->a2dp_bit_pool < 255))
3165                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3166                                                         true, 107);
3167                         else
3168                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3169                                                         true, 105);
3170                 } else
3171                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3172                                                 106);
3173
3174         }
3175
3176 }
3177
3178
3179 /* PAN(EDR)+A2DP */
3180 void halbtc8723d2ant_action_pan_edr_a2dp(IN struct btc_coexist *btcoexist)
3181 {
3182         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3183         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3184         u8              wifi_rssi_state, bt_rssi_state;
3185
3186         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3187         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3188         u8              wifi_rssi_state2, bt_rssi_state2;
3189         boolean wifi_busy = false, wifi_turbo = false;
3190
3191
3192         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3193         btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
3194                            &coex_sta->scan_ap_num);
3195         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3196                         "############# [BTCoex],  scan_ap_num = %d, wl_noisy = %d\n",
3197                         coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3198         BTC_TRACE(trace_buf);
3199
3200 #if 1
3201         if ((wifi_busy) && (coex_sta->wl_noisy_level == 0))
3202                 wifi_turbo = true;
3203 #endif
3204
3205
3206         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3207                           &prewifi_rssi_state, 2,
3208                           coex_sta->wifi_coex_thres , 0);
3209
3210         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3211                            &prewifi_rssi_state2, 2,
3212                            coex_sta->wifi_coex_thres2 , 0);
3213
3214         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3215                         coex_sta->bt_coex_thres , 0);
3216
3217         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3218                          coex_sta->bt_coex_thres2 , 0);
3219
3220         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3221                 BTC_RSSI_HIGH(bt_rssi_state)) {
3222
3223                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3224                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3225
3226                 coex_dm->is_switch_to_1dot5_ant = false;
3227
3228                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3229                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3230         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3231                    BTC_RSSI_HIGH(bt_rssi_state2)) {
3232
3233                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3234                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3235
3236                 coex_dm->is_switch_to_1dot5_ant = false;
3237
3238                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3239
3240                 if (wifi_busy) {
3241
3242                         if (((coex_sta->a2dp_bit_pool > 40) &&
3243                                  (coex_sta->a2dp_bit_pool < 255)) ||
3244                                 (!coex_sta->is_A2DP_3M))
3245                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3246                                                         true, 7);
3247                         else
3248                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3249                                                         true, 5);
3250                 } else
3251                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3252                                                 6);
3253         } else {
3254
3255                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3256                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3257
3258                 coex_dm->is_switch_to_1dot5_ant = true;
3259
3260                 if (wifi_turbo)
3261                         halbtc8723d2ant_coex_table_with_type(btcoexist,
3262                                                                  NORMAL_EXEC, 6);
3263                 else
3264                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC,
3265                                                                  7);
3266
3267                 if (wifi_busy) {
3268
3269                         if ((coex_sta->a2dp_bit_pool > 40) &&
3270                                 (coex_sta->a2dp_bit_pool < 255))
3271                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3272                                                         true, 107);
3273                         else if (wifi_turbo)
3274                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3275                                                         true, 108);
3276                         else
3277                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3278                                                         true, 105);
3279                 } else
3280                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3281                                                 106);
3282
3283         }
3284
3285 }
3286
3287
3288 void halbtc8723d2ant_action_pan_edr_hid(IN struct btc_coexist *btcoexist)
3289 {
3290         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3291         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3292         u8              wifi_rssi_state, bt_rssi_state;
3293
3294         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3295         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3296         u8      wifi_rssi_state2, bt_rssi_state2;
3297         boolean wifi_busy = false;
3298         u32 wifi_bw = 1;
3299
3300         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3301                            &wifi_bw);
3302
3303         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3304
3305         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3306                           &prewifi_rssi_state, 2,
3307                           coex_sta->wifi_coex_thres , 0);
3308
3309         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3310                            &prewifi_rssi_state2, 2,
3311                            coex_sta->wifi_coex_thres2 , 0);
3312
3313         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3314                         coex_sta->bt_coex_thres , 0);
3315
3316         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3317                          coex_sta->bt_coex_thres2 , 0);
3318
3319
3320         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3321                 BTC_RSSI_HIGH(bt_rssi_state)) {
3322
3323                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3324                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3325
3326                 coex_dm->is_switch_to_1dot5_ant = false;
3327
3328                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3329                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3330         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3331                    BTC_RSSI_HIGH(bt_rssi_state2)) {
3332
3333                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3334                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3335
3336                 coex_dm->is_switch_to_1dot5_ant = false;
3337
3338                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3339
3340                 if (wifi_busy)
3341                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3342                                                 3);
3343                 else
3344                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3345                                                 4);
3346         } else {
3347
3348                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3349                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3350
3351                 coex_dm->is_switch_to_1dot5_ant = true;
3352
3353                 if (coex_sta->hid_busy_num >= 2) {
3354
3355                         halbtc8723d2ant_coex_table_with_type(btcoexist,
3356                                                          NORMAL_EXEC, 8);
3357                         if (wifi_bw == 0)  /*11bg mode */
3358                                 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3359                                                                 NORMAL_EXEC,
3360                                                                 0x1, 0xaa,
3361                                                                 0x5a, 0xaa,
3362                                                                 0xaa);
3363                         else
3364                                 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3365                                                                 NORMAL_EXEC,
3366                                                                 0x2, 0xaa,
3367                                                                 0x5a, 0xaa,
3368                                                                 0xaa);
3369                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3370                                                 110);
3371                 } else {
3372
3373                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3374
3375                         if (wifi_busy)
3376                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3377                                                         103);
3378                         else
3379                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3380                                                         104);
3381                 }
3382
3383         }
3384
3385 }
3386
3387
3388 /* HID+A2DP+PAN(EDR) */
3389 void halbtc8723d2ant_action_hid_a2dp_pan_edr(IN struct btc_coexist *btcoexist)
3390 {
3391         static u8       prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3392         static u8       pre_bt_rssi_state = BTC_RSSI_STATE_LOW;
3393         u8      wifi_rssi_state, bt_rssi_state;
3394
3395         static u8       prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3396         static u8       pre_bt_rssi_state2 = BTC_RSSI_STATE_LOW;
3397         u8      wifi_rssi_state2, bt_rssi_state2;
3398         boolean wifi_busy = false;
3399         u32 wifi_bw = 1;
3400
3401         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
3402                            &wifi_bw);
3403
3404         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3405
3406         wifi_rssi_state = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3407                           &prewifi_rssi_state, 2,
3408                           coex_sta->wifi_coex_thres , 0);
3409
3410         wifi_rssi_state2 = halbtc8723d2ant_wifi_rssi_state(btcoexist,
3411                            &prewifi_rssi_state2, 2,
3412                            coex_sta->wifi_coex_thres2 , 0);
3413
3414         bt_rssi_state = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state, 2,
3415                         coex_sta->bt_coex_thres , 0);
3416
3417         bt_rssi_state2 = halbtc8723d2ant_bt_rssi_state(&pre_bt_rssi_state2, 2,
3418                          coex_sta->bt_coex_thres2 , 0);
3419
3420
3421         if (BTC_RSSI_HIGH(wifi_rssi_state) &&
3422                 BTC_RSSI_HIGH(bt_rssi_state)) {
3423
3424                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3425                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3426
3427                 coex_dm->is_switch_to_1dot5_ant = false;
3428
3429                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3430                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3431         } else if (BTC_RSSI_HIGH(wifi_rssi_state2) &&
3432                    BTC_RSSI_HIGH(bt_rssi_state2)) {
3433
3434                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
3435                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 2);
3436
3437                 coex_dm->is_switch_to_1dot5_ant = false;
3438
3439                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
3440
3441                 if (wifi_busy) {
3442
3443                         if (((coex_sta->a2dp_bit_pool > 40) &&
3444                                  (coex_sta->a2dp_bit_pool < 255)) ||
3445                                 (!coex_sta->is_A2DP_3M))
3446                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3447                                                         true, 7);
3448                         else
3449                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3450                                                         true, 5);
3451                 } else
3452                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3453                                                 6);
3454         } else {
3455
3456                 halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3457                 halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3458
3459                 coex_dm->is_switch_to_1dot5_ant = true;
3460
3461                 if (coex_sta->hid_busy_num >= 2) {
3462                         halbtc8723d2ant_coex_table_with_type(btcoexist,
3463                                                          NORMAL_EXEC, 8);
3464                         if (wifi_bw == 0)  /*11bg mode */
3465                                 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3466                                                                 NORMAL_EXEC,
3467                                                                 0x1, 0xaa,
3468                                                                 0x5a, 0xaa,
3469                                                                 0xaa);
3470                         else
3471                                 halbtc8723d2ant_set_wltoggle_coex_table(btcoexist,
3472                                                                 NORMAL_EXEC,
3473                                                                 0x2, 0xaa,
3474                                                                 0x5a, 0xaa,
3475                                                                 0xaa);
3476                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3477                                                 110);
3478                 } else {
3479                         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
3480
3481                         if (wifi_busy) {
3482
3483                                 if ((coex_sta->a2dp_bit_pool > 40) &&
3484                                         (coex_sta->a2dp_bit_pool < 255))
3485                                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3486                                                                 true, 107);
3487                                 else
3488                                         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC,
3489                                                                 true, 105);
3490                         } else
3491                                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
3492                                                         106);
3493                 }
3494         }
3495
3496 }
3497
3498
3499 void halbtc8723d2ant_action_wifi_multi_port(IN struct btc_coexist *btcoexist)
3500 {
3501         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3502         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3503
3504         /* hw all off */
3505         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3506
3507         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3508 }
3509
3510 void halbtc8723d2ant_action_wifi_linkscan_process(IN struct btc_coexist *btcoexist)
3511 {
3512         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3513
3514         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 0x18);
3515         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3516
3517         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3518
3519         if (bt_link_info->pan_exist) {
3520
3521                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
3522
3523                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3524
3525         } else if (bt_link_info->a2dp_exist) {
3526
3527                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
3528
3529                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3530         } else {
3531
3532                 halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 21);
3533
3534                 halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 8);
3535         }
3536
3537 }
3538
3539 void halbtc8723d2ant_action_wifi_not_connected(IN struct btc_coexist *btcoexist)
3540 {
3541         halbtc8723d2ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
3542
3543         /* fw all off */
3544         halbtc8723d2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3545
3546         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3547         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3548 }
3549
3550 void halbtc8723d2ant_action_wifi_connected(IN struct btc_coexist *btcoexist)
3551 {
3552         switch (coex_dm->cur_algorithm) {
3553
3554         case BT_8723D_2ANT_COEX_ALGO_SCO:
3555                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3556                         "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
3557                 BTC_TRACE(trace_buf);
3558                 halbtc8723d2ant_action_sco(btcoexist);
3559                 break;
3560         case BT_8723D_2ANT_COEX_ALGO_HID:
3561                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3562                         "[BTCoex], Action 2-Ant, algorithm = HID.\n");
3563                 BTC_TRACE(trace_buf);
3564                 halbtc8723d2ant_action_hid(btcoexist);
3565                 break;
3566         case BT_8723D_2ANT_COEX_ALGO_A2DP:
3567                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3568                         "[BTCoex], Action 2-Ant, algorithm = A2DP.\n");
3569                 BTC_TRACE(trace_buf);
3570                 halbtc8723d2ant_action_a2dp(btcoexist);
3571                 break;
3572         case BT_8723D_2ANT_COEX_ALGO_A2DP_PANHS:
3573                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3574                         "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n");
3575                 BTC_TRACE(trace_buf);
3576                 halbtc8723d2ant_action_a2dp_pan_hs(btcoexist);
3577                 break;
3578         case BT_8723D_2ANT_COEX_ALGO_PANEDR:
3579                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3580                         "[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n");
3581                 BTC_TRACE(trace_buf);
3582                 halbtc8723d2ant_action_pan_edr(btcoexist);
3583                 break;
3584         case BT_8723D_2ANT_COEX_ALGO_PANEDR_A2DP:
3585                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3586                         "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n");
3587                 BTC_TRACE(trace_buf);
3588                 halbtc8723d2ant_action_pan_edr_a2dp(btcoexist);
3589                 break;
3590         case BT_8723D_2ANT_COEX_ALGO_PANEDR_HID:
3591                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3592                         "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n");
3593                 BTC_TRACE(trace_buf);
3594                 halbtc8723d2ant_action_pan_edr_hid(btcoexist);
3595                 break;
3596         case BT_8723D_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3597                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3598                         "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n");
3599                 BTC_TRACE(trace_buf);
3600                 halbtc8723d2ant_action_hid_a2dp_pan_edr(
3601                         btcoexist);
3602                 break;
3603         case BT_8723D_2ANT_COEX_ALGO_HID_A2DP:
3604                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3605                         "[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n");
3606                 BTC_TRACE(trace_buf);
3607                 halbtc8723d2ant_action_hid_a2dp(btcoexist);
3608                 break;
3609         case BT_8723D_2ANT_COEX_ALGO_NOPROFILEBUSY:
3610                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3611                         "[BTCoex], Action 2-Ant, algorithm = No-Profile busy.\n");
3612                 BTC_TRACE(trace_buf);
3613                 halbtc8723d2ant_action_bt_idle(btcoexist);
3614                 break;
3615         default:
3616                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3617                         "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3618                 BTC_TRACE(trace_buf);
3619                 halbtc8723d2ant_action_coex_all_off(btcoexist);
3620                 break;
3621                 }
3622
3623          coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3624
3625 }
3626
3627
3628 void halbtc8723d2ant_run_coexist_mechanism(IN struct btc_coexist *btcoexist)
3629 {
3630         u8      algorithm = 0;
3631         u32     num_of_wifi_link = 0;
3632         u32     wifi_link_status = 0;
3633         struct  btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3634         boolean miracast_plus_bt = false;
3635         boolean scan = false, link = false, roam = false,
3636                         under_4way = false,
3637                         wifi_connected = false, wifi_under_5g = false,
3638                         bt_hs_on = false;
3639
3640         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3641         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3642         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3643         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
3644                            &under_4way);
3645
3646         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3647                         "[BTCoex], RunCoexistMechanism()===>\n");
3648         BTC_TRACE(trace_buf);
3649
3650         if (btcoexist->manual_control) {
3651                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3652                         "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3653                 BTC_TRACE(trace_buf);
3654                 return;
3655         }
3656
3657         if (btcoexist->stop_coex_dm) {
3658                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3659                         "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
3660                 BTC_TRACE(trace_buf);
3661                 return;
3662         }
3663
3664         if (coex_sta->under_ips) {
3665                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3666                                 "[BTCoex], wifi is under IPS !!!\n");
3667                 BTC_TRACE(trace_buf);
3668                 return;
3669         }
3670
3671         if (!coex_sta->run_time_state) {
3672                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3673                         "[BTCoex], return for run_time_state = false !!!\n");
3674                 BTC_TRACE(trace_buf);
3675                 return;
3676         }
3677
3678         if (coex_sta->freeze_coexrun_by_btinfo) {
3679                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3680                         "[BTCoex], BtInfoNotify(), return for freeze_coexrun_by_btinfo\n");
3681                 BTC_TRACE(trace_buf);
3682                 return;
3683         }
3684
3685         if (coex_sta->bt_whck_test) {
3686                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3687                                 "[BTCoex], BT is under WHCK TEST!!!\n");
3688                 BTC_TRACE(trace_buf);
3689                 halbtc8723d2ant_action_bt_whql_test(btcoexist);
3690                 return;
3691         }
3692
3693         if (coex_sta->bt_disabled) {
3694                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3695                                  "[BTCoex], BT is disabled!!!\n");
3696                 BTC_TRACE(trace_buf);
3697                 halbtc8723d2ant_action_coex_all_off(btcoexist);
3698                 return;
3699         }
3700
3701         if (coex_sta->c2h_bt_inquiry_page) {
3702                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3703                                 "[BTCoex], BT is under inquiry/page scan !!\n");
3704                 BTC_TRACE(trace_buf);
3705                 halbtc8723d2ant_action_bt_inquiry(btcoexist);
3706                 return;
3707         }
3708
3709         if (coex_sta->is_setupLink) {
3710                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3711                                  "[BTCoex], BT is re-link !!!\n");
3712                 halbtc8723d2ant_action_bt_relink(btcoexist);
3713                 return;
3714         }
3715
3716         /* for P2P */
3717         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
3718                            &wifi_link_status);
3719         num_of_wifi_link = wifi_link_status >> 16;
3720
3721         if ((num_of_wifi_link >= 2) ||
3722                 (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
3723                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3724                         "############# [BTCoex],  Multi-Port num_of_wifi_link = %d, wifi_link_status = 0x%x\n",
3725                                 num_of_wifi_link, wifi_link_status);
3726                 BTC_TRACE(trace_buf);
3727
3728                 if (bt_link_info->bt_link_exist)
3729                         miracast_plus_bt = true;
3730                 else
3731                         miracast_plus_bt = false;
3732
3733                 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3734                                    &miracast_plus_bt);
3735
3736                 if (scan || link || roam || under_4way) {
3737                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3738                                 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
3739                                     scan, link, roam, under_4way);
3740                         BTC_TRACE(trace_buf);
3741
3742                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3743                                 "[BTCoex], wifi is under linkscan process + Multi-Port !!\n");
3744                         BTC_TRACE(trace_buf);
3745
3746                         halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3747                 } else
3748                         halbtc8723d2ant_action_wifi_multi_port(btcoexist);
3749
3750                 return;
3751         } else {
3752                 miracast_plus_bt = false;
3753                 btcoexist->btc_set(btcoexist, BTC_SET_BL_MIRACAST_PLUS_BT,
3754                                    &miracast_plus_bt);
3755         }
3756
3757         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3758
3759         if (bt_hs_on) {
3760                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3761                                         "############# [BTCoex],  BT Is hs\n");
3762                         BTC_TRACE(trace_buf);
3763                         halbtc8723d2ant_action_bt_hs(btcoexist);
3764                         return;
3765         }
3766
3767         if ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
3768                         coex_dm->bt_status) ||
3769                    (BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE ==
3770                         coex_dm->bt_status)) {
3771
3772                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3773                                 "[BTCoex], Action 2-Ant, bt idle!!.\n");
3774                 BTC_TRACE(trace_buf);
3775
3776                 halbtc8723d2ant_action_bt_idle(btcoexist);
3777                 return;
3778         }
3779
3780         algorithm = halbtc8723d2ant_action_algorithm(btcoexist);
3781         coex_dm->cur_algorithm = algorithm;
3782         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Algorithm = %d\n",
3783                         coex_dm->cur_algorithm);
3784         BTC_TRACE(trace_buf);
3785
3786         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3787                            &wifi_connected);
3788
3789         if (scan || link || roam || under_4way) {
3790                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3791                                 "[BTCoex], WiFi is under Link Process !!\n");
3792                 BTC_TRACE(trace_buf);
3793                 halbtc8723d2ant_action_wifi_linkscan_process(btcoexist);
3794         } else if (wifi_connected) {
3795
3796                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3797                                 "[BTCoex], Action 2-Ant, wifi connected!!.\n");
3798                 BTC_TRACE(trace_buf);
3799                 halbtc8723d2ant_action_wifi_connected(btcoexist);
3800
3801         } else {
3802
3803                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3804                                 "[BTCoex], Action 2-Ant, wifi not-connected!!.\n");
3805                 BTC_TRACE(trace_buf);
3806                 halbtc8723d2ant_action_wifi_not_connected(btcoexist);
3807         }
3808 }
3809
3810
3811 void halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
3812 {
3813         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3814                     "[BTCoex], Coex Mechanism Init!!\n");
3815         BTC_TRACE(trace_buf);
3816
3817         halbtc8723d2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x18);
3818         halbtc8723d2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, 0);
3819
3820         /* sw all off */
3821         halbtc8723d2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, false);
3822
3823         coex_sta->pop_event_cnt = 0;
3824         coex_sta->cnt_RemoteNameReq = 0;
3825         coex_sta->cnt_ReInit = 0;
3826         coex_sta->cnt_setupLink = 0;
3827         coex_sta->cnt_IgnWlanAct = 0;
3828         coex_sta->cnt_Page = 0;
3829
3830         halbtc8723d2ant_query_bt_info(btcoexist);
3831 }
3832
3833
3834 void halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
3835                                     IN boolean wifi_only)
3836 {
3837         u8      u8tmp0 = 0, u8tmp1 = 0;
3838         u32     vendor;
3839         u32     u32tmp0 = 0, u32tmp1 = 0, u32tmp2 = 0;
3840         u16 u16tmp1 = 0;
3841         u8 i = 0;
3842
3843
3844         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3845                     "[BTCoex], 2Ant Init HW Config!!\n");
3846         BTC_TRACE(trace_buf);
3847
3848 #if BT_8723D_2ANT_COEX_DBG
3849         u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
3850                         0x38);
3851         u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
3852                         0x54);
3853         u16tmp1 = btcoexist->btc_read_2byte(btcoexist, 0x948);
3854         u8tmp1  = btcoexist->btc_read_1byte(btcoexist, 0x73);
3855         u8tmp0 =  btcoexist->btc_read_1byte(btcoexist, 0x67);
3856
3857         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3858                 "[BTCoex], ********** 0x67 = 0x%x, 0x948 = 0x%x, 0x73 = 0x%x(Before init_hw_config)\n",
3859                     u8tmp0, u16tmp1, u8tmp1);
3860         BTC_TRACE(trace_buf);
3861
3862         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3863                 "[BTCoex], **********0x38= 0x%x, 0x54= 0x%x (Before init_hw_config)\n",
3864                     u32tmp1, u32tmp2);
3865         BTC_TRACE(trace_buf);
3866 #endif
3867
3868
3869         coex_sta->bt_coex_supported_feature = 0;
3870         coex_sta->bt_coex_supported_version = 0;
3871         coex_sta->bt_ble_scan_type = 0;
3872         coex_sta->bt_ble_scan_para[0] = 0;
3873         coex_sta->bt_ble_scan_para[1] = 0;
3874         coex_sta->bt_ble_scan_para[2] = 0;
3875         coex_sta->bt_reg_vendor_ac = 0xffff;
3876         coex_sta->bt_reg_vendor_ae = 0xffff;
3877         coex_sta->gnt_error_cnt = 0;
3878         coex_sta->bt_relink_downcount = 0;
3879
3880         for (i = 0; i <= 9; i++)
3881                 coex_sta->bt_afh_map[i] = 0;
3882
3883 #if 0
3884         btcoexist->btc_get(btcoexist, BTC_GET_U4_VENDOR, &vendor);
3885         if (vendor == BTC_VENDOR_LENOVO)
3886                 coex_dm->switch_thres_offset = 0;
3887         else
3888                 coex_dm->switch_thres_offset = 20;
3889 #endif
3890         /* 0xf0[15:12] --> Chip Cut information */
3891         coex_sta->cut_version = (btcoexist->btc_read_1byte(btcoexist,
3892                                  0xf1) & 0xf0) >> 4;
3893
3894         coex_sta->dis_ver_info_cnt = 0;
3895
3896         /* default isolation = 15dB */
3897         coex_sta->isolation_btween_wb = BT_8723D_2ANT_DEFAULT_ISOLATION;
3898         halbtc8723d2ant_coex_switch_threshold(btcoexist,
3899                                               coex_sta->isolation_btween_wb);
3900
3901         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x550, 0x8,
3902                                            0x1);  /* enable TBTT nterrupt */
3903
3904         /* BT report packet sample rate  */
3905         btcoexist->btc_write_1byte(btcoexist, 0x790, 0x5);
3906
3907         /* Init 0x778 = 0x1 for 2-Ant */
3908         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1);
3909
3910         /* Enable PTA (3-wire function form BT side) */
3911         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3912         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x41, 0x02, 0x1);
3913
3914         /* Enable PTA (tx/rx signal form WiFi side) */
3915         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x4c6, 0x10, 0x1);
3916
3917         halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, true);
3918
3919         /* check if WL firmware download ok */
3920         if (btcoexist->btc_read_1byte(btcoexist, 0x80) == 0xc6)
3921                 halbtc8723d2ant_post_state_to_bt(btcoexist,
3922                                          BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
3923
3924         /* Enable counter statistics */
3925         btcoexist->btc_write_1byte(btcoexist, 0x76e,
3926                            0x4); /* 0x76e[3] =1, WLAN_Act control by PTA */
3927
3928         /* WLAN_Tx by GNT_WL  0x950[29] = 0 */
3929         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x20, 0x0);
3930
3931         halbtc8723d2ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
3932
3933         halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
3934
3935         psd_scan->ant_det_is_ant_det_available = true;
3936
3937         if (wifi_only) {
3938                 coex_sta->concurrent_rx_mode_on = false;
3939                 /* Path config   */
3940                 /* Set Antenna Path */
3941                 halbtc8723d2ant_set_ant_path(btcoexist,
3942                                              BTC_ANT_PATH_AUTO,
3943                                              FORCE_EXEC,
3944                                              BT_8723D_2ANT_PHASE_WLANONLY_INIT);
3945
3946                 btcoexist->stop_coex_dm = true;
3947         } else {
3948                 /*Set BT polluted packet on for Tx rate adaptive not including Tx retry break by PTA, 0x45c[19] =1 */
3949                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x45e, 0x8, 0x1);
3950
3951                 coex_sta->concurrent_rx_mode_on = true;
3952                 /* btcoexist->btc_write_1byte_bitmask(btcoexist, 0x953, 0x2, 0x1); */
3953
3954                 /* RF 0x1[0] = 0->Set GNT_WL_RF_Rx always = 1 for con-current Rx */
3955                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0x1, 0x0);
3956
3957                 /* Path config   */
3958                 halbtc8723d2ant_set_ant_path(btcoexist,
3959                                              BTC_ANT_PATH_AUTO,
3960                                              FORCE_EXEC,
3961                                              BT_8723D_2ANT_PHASE_COEX_INIT);
3962
3963                 btcoexist->stop_coex_dm = false;
3964         }
3965
3966
3967 }
3968
3969 u32 halbtc8723d2ant_psd_log2base(IN struct btc_coexist *btcoexist, IN u32 val)
3970 {
3971         u8      j;
3972         u32     tmp, tmp2, val_integerd_b = 0, tindex, shiftcount = 0;
3973         u32     result, val_fractiond_b = 0, table_fraction[21] = {0, 432, 332, 274, 232, 200,
3974                                    174, 151, 132, 115, 100, 86, 74, 62, 51, 42,
3975                                                            32, 23, 15, 7, 0
3976                                                               };
3977
3978         if (val == 0)
3979                 return 0;
3980
3981         tmp = val;
3982
3983         while (1) {
3984                 if (tmp == 1)
3985                         break;
3986                 else {
3987                         tmp = (tmp >> 1);
3988                         shiftcount++;
3989                 }
3990         }
3991
3992
3993         val_integerd_b = shiftcount + 1;
3994
3995         tmp2 = 1;
3996         for (j = 1; j <= val_integerd_b; j++)
3997                 tmp2 = tmp2 * 2;
3998
3999         tmp = (val * 100) / tmp2;
4000         tindex = tmp / 5;
4001
4002         if (tindex > 20)
4003                 tindex = 20;
4004
4005         val_fractiond_b = table_fraction[tindex];
4006
4007         result = val_integerd_b * 100 - val_fractiond_b;
4008
4009         return result;
4010
4011
4012 }
4013
4014 void halbtc8723d2ant_psd_show_antenna_detect_result(IN struct btc_coexist
4015                 *btcoexist)
4016 {
4017         u8              *cli_buf = btcoexist->cli_buf;
4018         struct  btc_board_info  *board_info = &btcoexist->board_info;
4019
4020         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4021                    "\r\n============[Antenna Detection info]  ============\n");
4022         CL_PRINTF(cli_buf);
4023
4024         if (psd_scan->ant_det_result == 12) { /* Get Ant Det from BT  */
4025
4026                 if (board_info->btdm_ant_num_by_ant_det == 1)
4027                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4028                                    "\r\n %-35s = %s (%d~%d)",
4029                                    "Ant Det Result", "1-Antenna",
4030                                    BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4031                                 BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION);
4032                 else {
4033
4034                         if (psd_scan->ant_det_psd_scan_peak_val >
4035                             (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
4036                             * 100)
4037                                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4038                                            "\r\n %-35s = %s (>%d)",
4039                                         "Ant Det Result", "2-Antenna (Bad-Isolation)",
4040                                         BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4041                         else
4042                                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4043                                            "\r\n %-35s = %s (%d~%d)",
4044                                         "Ant Det Result", "2-Antenna (Good-Isolation)",
4045                                         BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4046                                            + psd_scan->ant_det_thres_offset,
4047                                         BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4048                 }
4049
4050         } else if (psd_scan->ant_det_result == 1)
4051                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (>%d)",
4052                            "Ant Det Result", "2-Antenna (Bad-Isolation)",
4053                            BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4054         else if (psd_scan->ant_det_result == 2)
4055                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4056                            "Ant Det Result", "2-Antenna (Good-Isolation)",
4057                            BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4058                            + psd_scan->ant_det_thres_offset,
4059                            BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION);
4060         else
4061                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (%d~%d)",
4062                            "Ant Det Result", "1-Antenna",
4063                            BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT,
4064                            BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
4065                            + psd_scan->ant_det_thres_offset);
4066
4067         CL_PRINTF(cli_buf);
4068
4069         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s ",
4070                    "Antenna Detection Finish",
4071                    (board_info->btdm_ant_det_finish
4072                     ? "Yes" : "No"));
4073         CL_PRINTF(cli_buf);
4074
4075         switch (psd_scan->ant_det_result) {
4076         case 0:
4077                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4078                            "(BT is not available)");
4079                 break;
4080         case 1:  /* 2-Ant bad-isolation */
4081                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4082                            "(BT is available)");
4083                 break;
4084         case 2:  /* 2-Ant good-isolation */
4085                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4086                            "(BT is available)");
4087                 break;
4088         case 3:  /* 1-Ant */
4089                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4090                            "(BT is available)");
4091                 break;
4092         case 4:
4093                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4094                            "(Uncertainty result)");
4095                 break;
4096         case 5:
4097                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "(Pre-Scan fai)");
4098                 break;
4099         case 6:
4100                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4101                            "(WiFi is Scanning)");
4102                 break;
4103         case 7:
4104                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4105                            "(BT is not idle)");
4106                 break;
4107         case 8:
4108                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4109                            "(Abort by WiFi Scanning)");
4110                 break;
4111         case 9:
4112                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4113                            "(Antenna Init is not ready)");
4114                 break;
4115         case 10:
4116                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4117                            "(BT is Inquiry or page)");
4118                 break;
4119         case 11:
4120                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4121                            "(BT is Disabled)");
4122         case 12:
4123                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4124                            "(BT is available, result from BT");
4125                 break;
4126         }
4127         CL_PRINTF(cli_buf);
4128
4129         if (psd_scan->ant_det_result == 12) {
4130                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4131                            "PSD Scan Peak Value",
4132                            psd_scan->ant_det_psd_scan_peak_val / 100);
4133                 CL_PRINTF(cli_buf);
4134                 return;
4135         }
4136
4137         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4138                    "Ant Detect Total Count", psd_scan->ant_det_try_count);
4139         CL_PRINTF(cli_buf);
4140
4141         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4142                    "Ant Detect Fail Count", psd_scan->ant_det_fail_count);
4143         CL_PRINTF(cli_buf);
4144
4145         if ((!board_info->btdm_ant_det_finish) &&
4146             (psd_scan->ant_det_result != 5))
4147                 return;
4148
4149         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Response",
4150                    (psd_scan->ant_det_result ? "ok" : "fail"));
4151         CL_PRINTF(cli_buf);
4152
4153         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ms", "BT Tx Time",
4154                    psd_scan->ant_det_bt_tx_time);
4155         CL_PRINTF(cli_buf);
4156
4157         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "BT Tx Ch",
4158                    psd_scan->ant_det_bt_le_channel);
4159         CL_PRINTF(cli_buf);
4160
4161         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d",
4162                    "WiFi PSD Cent-Ch/Offset/Span",
4163                    psd_scan->real_cent_freq, psd_scan->real_offset,
4164                    psd_scan->real_span);
4165         CL_PRINTF(cli_buf);
4166
4167         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d dB",
4168                    "PSD Pre-Scan Peak Value",
4169                    psd_scan->ant_det_pre_psdscan_peak_val / 100);
4170         CL_PRINTF(cli_buf);
4171
4172         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s (<= %d)",
4173                    "PSD Pre-Scan result",
4174                    (psd_scan->ant_det_result != 5 ? "ok" : "fail"),
4175                    BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4176                    + psd_scan->ant_det_thres_offset);
4177         CL_PRINTF(cli_buf);
4178
4179         if (psd_scan->ant_det_result == 5)
4180                 return;
4181
4182         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s dB",
4183                    "PSD Scan Peak Value", psd_scan->ant_det_peak_val);
4184         CL_PRINTF(cli_buf);
4185
4186         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s MHz",
4187                    "PSD Scan Peak Freq", psd_scan->ant_det_peak_freq);
4188         CL_PRINTF(cli_buf);
4189
4190
4191         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "TFBGA Package",
4192                    (board_info->tfbga_package) ?  "Yes" : "No");
4193         CL_PRINTF(cli_buf);
4194
4195         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4196                    "PSD Threshold Offset", psd_scan->ant_det_thres_offset);
4197         CL_PRINTF(cli_buf);
4198
4199 }
4200
4201 void halbtc8723d2ant_psd_showdata(IN struct btc_coexist *btcoexist)
4202 {
4203         u8              *cli_buf = btcoexist->cli_buf;
4204         u32             delta_freq_per_point;
4205         u32             freq, freq1, freq2, n = 0, i = 0, j = 0, m = 0, psd_rep1, psd_rep2;
4206
4207         if (psd_scan->ant_det_result == 12)
4208                 return;
4209
4210         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4211                    "\r\n\n============[PSD info]  (%d)============\n",
4212                    psd_scan->psd_gen_count);
4213         CL_PRINTF(cli_buf);
4214
4215         if (psd_scan->psd_gen_count == 0) {
4216                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n No data !!\n");
4217                 CL_PRINTF(cli_buf);
4218                 return;
4219         }
4220
4221         if (psd_scan->psd_point == 0)
4222                 delta_freq_per_point = 0;
4223         else
4224                 delta_freq_per_point = psd_scan->psd_band_width /
4225                                        psd_scan->psd_point;
4226
4227         /* if (psd_scan->is_psd_show_max_only) */
4228         if (0) {
4229                 psd_rep1 = psd_scan->psd_max_value / 100;
4230                 psd_rep2 = psd_scan->psd_max_value - psd_rep1 * 100;
4231
4232                 freq = ((psd_scan->real_cent_freq - 20) * 1000000 +
4233                         psd_scan->psd_max_value_point * delta_freq_per_point);
4234                 freq1 = freq / 1000000;
4235                 freq2 = freq / 1000 - freq1 * 1000;
4236
4237                 if (freq2 < 100)
4238                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4239                                    "\r\n Freq = %d.0%d MHz",
4240                                    freq1, freq2);
4241                 else
4242                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4243                                    "\r\n Freq = %d.%d MHz",
4244                                    freq1, freq2);
4245
4246                 if (psd_rep2 < 10)
4247                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4248                                    ", Value = %d.0%d dB, (%d)\n",
4249                                    psd_rep1, psd_rep2, psd_scan->psd_max_value);
4250                 else
4251                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4252                                    ", Value = %d.%d dB, (%d)\n",
4253                                    psd_rep1, psd_rep2, psd_scan->psd_max_value);
4254
4255                 CL_PRINTF(cli_buf);
4256         } else {
4257                 m = psd_scan->psd_start_point;
4258                 n = psd_scan->psd_start_point;
4259                 i = 1;
4260                 j = 1;
4261
4262                 while (1) {
4263                         do {
4264                                 freq = ((psd_scan->real_cent_freq - 20) *
4265                                         1000000 + m *
4266                                         delta_freq_per_point);
4267                                 freq1 = freq / 1000000;
4268                                 freq2 = freq / 1000 - freq1 * 1000;
4269
4270                                 if (i == 1) {
4271                                         if (freq2 == 0)
4272                                                 CL_SPRINTF(cli_buf,
4273                                                            BT_TMP_BUF_SIZE,
4274                                                            "\r\n Freq%6d.000",
4275                                                            freq1);
4276                                         else if (freq2 < 100)
4277                                                 CL_SPRINTF(cli_buf,
4278                                                            BT_TMP_BUF_SIZE,
4279                                                            "\r\n Freq%6d.0%2d",
4280                                                            freq1,
4281                                                            freq2);
4282                                         else
4283                                                 CL_SPRINTF(cli_buf,
4284                                                            BT_TMP_BUF_SIZE,
4285                                                            "\r\n Freq%6d.%3d",
4286                                                            freq1,
4287                                                            freq2);
4288                                 } else if ((i % 8 == 0) ||
4289                                            (m == psd_scan->psd_stop_point)) {
4290                                         if (freq2 == 0)
4291                                                 CL_SPRINTF(cli_buf,
4292                                                            BT_TMP_BUF_SIZE,
4293                                                            "%6d.000\n", freq1);
4294                                         else if (freq2 < 100)
4295                                                 CL_SPRINTF(cli_buf,
4296                                                            BT_TMP_BUF_SIZE,
4297                                                            "%6d.0%2d\n", freq1,
4298                                                            freq2);
4299                                         else
4300                                                 CL_SPRINTF(cli_buf,
4301                                                            BT_TMP_BUF_SIZE,
4302                                                            "%6d.%3d\n", freq1,
4303                                                            freq2);
4304                                 } else {
4305                                         if (freq2 == 0)
4306                                                 CL_SPRINTF(cli_buf,
4307                                                            BT_TMP_BUF_SIZE,
4308                                                            "%6d.000", freq1);
4309                                         else if (freq2 < 100)
4310                                                 CL_SPRINTF(cli_buf,
4311                                                            BT_TMP_BUF_SIZE,
4312                                                            "%6d.0%2d", freq1,
4313                                                            freq2);
4314                                         else
4315                                                 CL_SPRINTF(cli_buf,
4316                                                            BT_TMP_BUF_SIZE,
4317                                                            "%6d.%3d", freq1,
4318                                                            freq2);
4319                                 }
4320
4321                                 i++;
4322                                 m++;
4323                                 CL_PRINTF(cli_buf);
4324
4325                         } while ((i <= 8) && (m <= psd_scan->psd_stop_point));
4326
4327
4328                         do {
4329                                 psd_rep1 = psd_scan->psd_report_max_hold[n] /
4330                                            100;
4331                                 psd_rep2 = psd_scan->psd_report_max_hold[n] -
4332                                            psd_rep1 *
4333                                            100;
4334
4335                                 if (j == 1) {
4336                                         if (psd_rep2 < 10)
4337                                                 CL_SPRINTF(cli_buf,
4338                                                            BT_TMP_BUF_SIZE,
4339                                                            "\r\n Val %7d.0%d",
4340                                                            psd_rep1,
4341                                                            psd_rep2);
4342                                         else
4343                                                 CL_SPRINTF(cli_buf,
4344                                                            BT_TMP_BUF_SIZE,
4345                                                            "\r\n Val %7d.%d",
4346                                                            psd_rep1,
4347                                                            psd_rep2);
4348                                 } else if ((j % 8 == 0)  ||
4349                                            (n == psd_scan->psd_stop_point)) {
4350                                         if (psd_rep2 < 10)
4351                                                 CL_SPRINTF(cli_buf,
4352                                                            BT_TMP_BUF_SIZE,
4353                                                         "%7d.0%d\n", psd_rep1,
4354                                                            psd_rep2);
4355                                         else
4356                                                 CL_SPRINTF(cli_buf,
4357                                                            BT_TMP_BUF_SIZE,
4358                                                            "%7d.%d\n", psd_rep1,
4359                                                            psd_rep2);
4360                                 } else {
4361                                         if (psd_rep2 < 10)
4362                                                 CL_SPRINTF(cli_buf,
4363                                                            BT_TMP_BUF_SIZE,
4364                                                            "%7d.0%d", psd_rep1,
4365                                                            psd_rep2);
4366                                         else
4367                                                 CL_SPRINTF(cli_buf,
4368                                                            BT_TMP_BUF_SIZE,
4369                                                            "%7d.%d", psd_rep1,
4370                                                            psd_rep2);
4371                                 }
4372
4373                                 j++;
4374                                 n++;
4375                                 CL_PRINTF(cli_buf);
4376
4377                         } while ((j <= 8) && (n <= psd_scan->psd_stop_point));
4378
4379                         if ((m > psd_scan->psd_stop_point) ||
4380                             (n > psd_scan->psd_stop_point))
4381                                 break;
4382                         else {
4383                                 i = 1;
4384                                 j = 1;
4385                         }
4386
4387                 }
4388         }
4389
4390
4391 }
4392
4393 #ifdef PLATFORM_WINDOWS
4394 #pragma optimize("", off)
4395 #endif
4396 void halbtc8723d2ant_psd_maxholddata(IN struct btc_coexist *btcoexist,
4397                                      IN u32 gen_count)
4398 {
4399         u32 i = 0;
4400         u32 loop_i_max = 0, loop_val_max = 0;
4401
4402         if (gen_count == 1) {
4403                 memcpy(psd_scan->psd_report_max_hold,
4404                        psd_scan->psd_report,
4405                        BT_8723D_2ANT_ANTDET_PSD_POINTS * sizeof(u32));
4406         }
4407
4408         for (i = psd_scan->psd_start_point;
4409              i <= psd_scan->psd_stop_point; i++) {
4410
4411                 /* update max-hold value at each freq point */
4412                 if (psd_scan->psd_report[i] > psd_scan->psd_report_max_hold[i])
4413                         psd_scan->psd_report_max_hold[i] =
4414                                 psd_scan->psd_report[i];
4415
4416                 /*      search the max value in this seep */
4417                 if (psd_scan->psd_report[i] > loop_val_max) {
4418                         loop_val_max = psd_scan->psd_report[i];
4419                         loop_i_max = i;
4420                 }
4421         }
4422
4423         if (gen_count <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)
4424                 psd_scan->psd_loop_max_value[gen_count - 1] = loop_val_max;
4425
4426 }
4427
4428
4429 #ifdef PLATFORM_WINDOWS
4430 #pragma optimize("", off)
4431 #endif
4432 u32 halbtc8723d2ant_psd_getdata(IN struct btc_coexist *btcoexist, IN u32 point)
4433 {
4434         /* reg 0x808[9:0]: FFT data x */
4435         /* reg 0x808[22]: 0-->1 to get 1 FFT data y */
4436         /* reg 0x8b4[15:0]: FFT data y report */
4437
4438         u32 val = 0, psd_report = 0;
4439         int k = 0;
4440
4441         val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4442
4443         val &= 0xffbffc00;
4444         val |= point;
4445
4446         btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4447
4448         val |= 0x00400000;
4449         btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4450
4451         while (1) {
4452                 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4453                         break;
4454         }
4455
4456         val = btcoexist->btc_read_4byte(btcoexist, 0x8b4);
4457
4458         psd_report = val & 0x0000ffff;
4459
4460         return psd_report;
4461 }
4462
4463 #ifdef PLATFORM_WINDOWS
4464 #pragma optimize("", off)
4465 #endif
4466 boolean halbtc8723d2ant_psd_sweep_point(IN struct btc_coexist *btcoexist,
4467                 IN u32 cent_freq, IN s32 offset, IN u32 span, IN u32 points,
4468                                         IN u32 avgnum, IN u32 loopcnt)
4469 {
4470         u32      i = 0, val = 0, n = 0, k = 0, j, point_index = 0;
4471         u32     points1 = 0, psd_report = 0;
4472         u32     start_p = 0, stop_p = 0, delta_freq_per_point = 156250;
4473         u32    psd_center_freq = 20 * 10 ^ 6;
4474         boolean outloop = false, scan , roam, is_sweep_ok = true;
4475         u8       flag = 0;
4476         u32     tmp = 0, u32tmp1 = 0;
4477         u32     wifi_original_channel = 1;
4478         u32 psd_sum = 0, avg_cnt = 0;
4479         u32     i_max = 0, val_max = 0, val_max2 = 0;
4480
4481         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4482                     "xxxxxxxxxxxxxxxx PSD Sweep Start!!\n");
4483         BTC_TRACE(trace_buf);
4484
4485         do {
4486                 switch (flag) {
4487                 case 0:  /* Get PSD parameters */
4488                 default:
4489
4490                         psd_scan->psd_band_width = 40 * 1000000;
4491                         psd_scan->psd_point = points;
4492                         psd_scan->psd_start_base = points / 2;
4493                         psd_scan->psd_avg_num = avgnum;
4494                         psd_scan->real_cent_freq = cent_freq;
4495                         psd_scan->real_offset = offset;
4496                         psd_scan->real_span = span;
4497
4498
4499                         points1 = psd_scan->psd_point;
4500                         delta_freq_per_point = psd_scan->psd_band_width /
4501                                                psd_scan->psd_point;
4502
4503                         /* PSD point setup */
4504                         val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4505                         val &= 0xffff0fff;
4506
4507                         switch (psd_scan->psd_point) {
4508                         case 128:
4509                                 val |= 0x0;
4510                                 break;
4511                         case 256:
4512                         default:
4513                                 val |= 0x00004000;
4514                                 break;
4515                         case 512:
4516                                 val |= 0x00008000;
4517                                 break;
4518                         case 1024:
4519                                 val |= 0x0000c000;
4520                                 break;
4521                         }
4522
4523                         switch (psd_scan->psd_avg_num) {
4524                         case 1:
4525                                 val |= 0x0;
4526                                 break;
4527                         case 8:
4528                                 val |= 0x00001000;
4529                                 break;
4530                         case 16:
4531                                 val |= 0x00002000;
4532                                 break;
4533                         case 32:
4534                         default:
4535                                 val |= 0x00003000;
4536                                 break;
4537                         }
4538                         btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4539
4540                         flag = 1;
4541                         break;
4542                 case 1:   /* calculate the PSD point index from freq/offset/span */
4543                         psd_center_freq = psd_scan->psd_band_width / 2 +
4544                                           offset * (1000000);
4545
4546                         start_p = psd_scan->psd_start_base + (psd_center_freq -
4547                                 span * (1000000) / 2) / delta_freq_per_point;
4548                         psd_scan->psd_start_point = start_p -
4549                                                     psd_scan->psd_start_base;
4550
4551                         stop_p = psd_scan->psd_start_base + (psd_center_freq +
4552                                 span * (1000000) / 2) / delta_freq_per_point;
4553                         psd_scan->psd_stop_point = stop_p -
4554                                                    psd_scan->psd_start_base - 1;
4555
4556                         flag = 2;
4557                         break;
4558                 case 2:  /* set RF channel/BW/Mode */
4559
4560                         /* set 3-wire off */
4561                         val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4562                         val |= 0x00300000;
4563                         btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4564
4565                         /* CCK off */
4566                         val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4567                         val &= 0xfeffffff;
4568                         btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4569
4570                         /* Tx-pause on */
4571                         btcoexist->btc_write_1byte(btcoexist, 0x522, 0x6f);
4572
4573                         /* store WiFi original channel */
4574                         wifi_original_channel = btcoexist->btc_get_rf_reg(
4575                                         btcoexist, BTC_RF_A, 0x18, 0x3ff);
4576
4577                         /* Set RF channel */
4578                         if (cent_freq == 2484)
4579                                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4580                                                           0x18, 0x3ff, 0xe);
4581                         else
4582                                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
4583                                           0x18, 0x3ff, (cent_freq - 2412) / 5 +
4584                                                   1); /* WiFi TRx Mask on */
4585
4586                         /* save original RCK value */
4587                         u32tmp1 =  btcoexist->btc_get_rf_reg(
4588                                            btcoexist, BTC_RF_A, 0x1d, 0xfffff);
4589
4590                         /* Enter debug mode */
4591                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4592                                                   0x2, 0x1);
4593
4594                         /* Set RF Rx filter corner */
4595                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4596                                                   0xfffff, 0x2e);
4597
4598
4599                         /* Set  RF mode = Rx, RF Gain = 0x320a0 */
4600                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x0,
4601                                                   0xfffff, 0x320a0);
4602
4603                         while (1) {
4604                                 if (k++ > BT_8723D_2ANT_ANTDET_SWEEPPOINT_DELAY)
4605                                         break;
4606                         }
4607                         flag = 3;
4608                         break;
4609                 case 3:
4610                         psd_scan->psd_gen_count = 0;
4611                         for (j = 1; j <= loopcnt; j++) {
4612
4613                                 btcoexist->btc_get(btcoexist,
4614                                                    BTC_GET_BL_WIFI_SCAN, &scan);
4615                                 btcoexist->btc_get(btcoexist,
4616                                                    BTC_GET_BL_WIFI_ROAM, &roam);
4617
4618                                 if (scan || roam) {
4619                                         is_sweep_ok = false;
4620                                         break;
4621                                 }
4622                                 memset(psd_scan->psd_report, 0,
4623                                        psd_scan->psd_point * sizeof(u32));
4624                                 start_p = psd_scan->psd_start_point +
4625                                           psd_scan->psd_start_base;
4626                                 stop_p = psd_scan->psd_stop_point +
4627                                          psd_scan->psd_start_base + 1;
4628
4629                                 i = start_p;
4630                                 point_index = 0;
4631
4632                                 while (i < stop_p) {
4633                                         if (i >= points1)
4634                                                 psd_report =
4635                                                         halbtc8723d2ant_psd_getdata(
4636                                                         btcoexist, i - points1);
4637                                         else
4638                                                 psd_report =
4639                                                         halbtc8723d2ant_psd_getdata(
4640                                                                 btcoexist, i);
4641
4642                                         if (psd_report == 0)
4643                                                 tmp = 0;
4644                                         else
4645                                                 /* tmp =  20*log10((double)psd_report); */
4646                                                 /* 20*log2(x)/log2(10), log2Base return theresult of the psd_report*100 */
4647                                                 tmp = 6 * halbtc8723d2ant_psd_log2base(
4648                                                         btcoexist, psd_report);
4649
4650                                         n = i - psd_scan->psd_start_base;
4651                                         psd_scan->psd_report[n] =  tmp;
4652
4653                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4654                                                 "Point=%d, psd_dB_data = %d\n",
4655                                                     i, psd_scan->psd_report[n]);
4656                                         BTC_TRACE(trace_buf);
4657
4658                                         i++;
4659
4660                                 }
4661
4662                                 halbtc8723d2ant_psd_maxholddata(btcoexist, j);
4663
4664                                 psd_scan->psd_gen_count = j;
4665
4666                                 /*Accumulate Max PSD value in this loop if the value > threshold */
4667                                 if (psd_scan->psd_loop_max_value[j - 1] >=
4668                                     4000) {
4669                                         psd_sum = psd_sum +
4670                                                 psd_scan->psd_loop_max_value[j -
4671                                                                        1];
4672                                         avg_cnt++;
4673                                 }
4674
4675                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4676                                             "Loop=%d, Max_dB_data = %d\n",
4677                                             j, psd_scan->psd_loop_max_value[j
4678                                                             - 1]);
4679                                 BTC_TRACE(trace_buf);
4680
4681                         }
4682
4683                         if (loopcnt == BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT) {
4684
4685                                 /* search the Max Value between each-freq-point-max-hold value of all sweep*/
4686                                 for (i = 1;
4687                                      i <= BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT;
4688                                      i++) {
4689
4690                                         if (i == 1) {
4691                                                 i_max = i;
4692                                                 val_max = psd_scan->psd_loop_max_value[i
4693                                                                        - 1];
4694                                                 val_max2 =
4695                                                         psd_scan->psd_loop_max_value[i
4696                                                                      - 1];
4697                                         } else if (
4698                                                 psd_scan->psd_loop_max_value[i -
4699                                                              1] > val_max) {
4700                                                 val_max2 = val_max;
4701                                                 i_max = i;
4702                                                 val_max = psd_scan->psd_loop_max_value[i
4703                                                                        - 1];
4704                                         } else if (
4705                                                 psd_scan->psd_loop_max_value[i -
4706                                                              1] > val_max2)
4707                                                 val_max2 =
4708                                                         psd_scan->psd_loop_max_value[i
4709                                                                      - 1];
4710
4711                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4712                                                 "i = %d, val_hold= %d, val_max = %d, val_max2 = %d\n",
4713                                                 i, psd_scan->psd_loop_max_value[i
4714                                                                     - 1],
4715                                                     val_max, val_max2);
4716
4717                                         BTC_TRACE(trace_buf);
4718                                 }
4719
4720                                 psd_scan->psd_max_value_point = i_max;
4721                                 psd_scan->psd_max_value = val_max;
4722                                 psd_scan->psd_max_value2 = val_max2;
4723
4724                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4725                                             "val_max = %d, val_max2 = %d\n",
4726                                             psd_scan->psd_max_value,
4727                                             psd_scan->psd_max_value2);
4728                                 BTC_TRACE(trace_buf);
4729                         }
4730
4731                         if (avg_cnt != 0) {
4732                                 psd_scan->psd_avg_value = (psd_sum / avg_cnt);
4733                                 if ((psd_sum % avg_cnt) >= (avg_cnt / 2))
4734                                         psd_scan->psd_avg_value++;
4735                         } else
4736                                 psd_scan->psd_avg_value = 0;
4737
4738                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4739                                     "AvgLoop=%d, Avg_dB_data = %d\n",
4740                                     avg_cnt, psd_scan->psd_avg_value);
4741                         BTC_TRACE(trace_buf);
4742
4743                         flag = 100;
4744                         break;
4745                 case 99:        /* error */
4746
4747                         outloop = true;
4748                         break;
4749                 case 100: /* recovery */
4750
4751                         /* set 3-wire on */
4752                         val = btcoexist->btc_read_4byte(btcoexist, 0x88c);
4753                         val &= 0xffcfffff;
4754                         btcoexist->btc_write_4byte(btcoexist, 0x88c, val);
4755
4756                         /* CCK on */
4757                         val = btcoexist->btc_read_4byte(btcoexist, 0x800);
4758                         val |= 0x01000000;
4759                         btcoexist->btc_write_4byte(btcoexist, 0x800, val);
4760
4761                         /* Tx-pause off */
4762                         btcoexist->btc_write_1byte(btcoexist, 0x522, 0x0);
4763
4764                         /* PSD off */
4765                         val = btcoexist->btc_read_4byte(btcoexist, 0x808);
4766                         val &= 0xffbfffff;
4767                         btcoexist->btc_write_4byte(btcoexist, 0x808, val);
4768
4769                         /* restore RF Rx filter corner */
4770                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1d,
4771                                                   0xfffff, u32tmp1);
4772
4773                         /* Exit debug mode */
4774                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xde,
4775                                                   0x2, 0x0);
4776
4777                         /* restore WiFi original channel */
4778                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x18,
4779                                                   0x3ff, wifi_original_channel);
4780
4781                         outloop = true;
4782                         break;
4783
4784                 }
4785
4786         } while (!outloop);
4787
4788         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4789                     "xxxxxxxxxxxxxxxx PSD Sweep Stop!!\n");
4790         BTC_TRACE(trace_buf);
4791         return is_sweep_ok;
4792
4793 }
4794
4795 #ifdef PLATFORM_WINDOWS
4796 #pragma optimize("", off)
4797 #endif
4798 boolean halbtc8723d2ant_psd_antenna_detection(IN struct btc_coexist
4799                 *btcoexist)
4800 {
4801         u32     i = 0;
4802         u32     wlpsd_cent_freq = 2484, wlpsd_span = 2;
4803         s32     wlpsd_offset = -4;
4804         u32 bt_tx_time, bt_le_channel;
4805         u8      bt_le_ch[13] = {3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 33};
4806
4807         u8      h2c_parameter[3] = {0}, u8tmpa, u8tmpb;
4808
4809         u8      state = 0;
4810         boolean         outloop = false, bt_resp = false, ant_det_finish = false;
4811         u32             freq, freq1, freq2, psd_rep1, psd_rep2, delta_freq_per_point,
4812                         u32tmp, u32tmp0, u32tmp1, u32tmp2 ;
4813         struct  btc_board_info  *board_info = &btcoexist->board_info;
4814
4815         memset(psd_scan->ant_det_peak_val, 0, 16 * sizeof(u8));
4816         memset(psd_scan->ant_det_peak_freq, 0, 16 * sizeof(u8));
4817
4818         psd_scan->ant_det_bt_tx_time =
4819                 BT_8723D_2ANT_ANTDET_BTTXTIME;     /* 0.42ms*50 = 20ms (0.42ms = 1 PSD sweep) */
4820         psd_scan->ant_det_bt_le_channel = BT_8723D_2ANT_ANTDET_BTTXCHANNEL;
4821
4822         bt_tx_time = psd_scan->ant_det_bt_tx_time;
4823         bt_le_channel = psd_scan->ant_det_bt_le_channel;
4824
4825         if (board_info->tfbga_package) /* for TFBGA */
4826                 psd_scan->ant_det_thres_offset = 5;
4827         else
4828                 psd_scan->ant_det_thres_offset = 0;
4829
4830         do {
4831                 switch (state) {
4832                 case 0:
4833                         if (bt_le_channel == 39)
4834                                 wlpsd_cent_freq = 2484;
4835                         else {
4836                                 for (i = 1; i <= 13; i++) {
4837                                         if (bt_le_ch[i - 1] ==
4838                                             bt_le_channel) {
4839                                                 wlpsd_cent_freq = 2412
4840                                                                   + (i - 1) * 5;
4841                                                 break;
4842                                         }
4843                                 }
4844
4845                                 if (i == 14) {
4846
4847                                         BTC_SPRINTF(trace_buf,
4848                                                     BT_TMP_BUF_SIZE,
4849                                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Abort!!, Invalid LE channel = %d\n ",
4850                                                     bt_le_channel);
4851                                         BTC_TRACE(trace_buf);
4852                                         outloop = true;
4853                                         break;
4854                                 }
4855                         }
4856 #if 0
4857                         wlpsd_sweep_count = bt_tx_time * 238 /
4858                                             100; /* bt_tx_time/0.42                                                              */
4859                         wlpsd_sweep_count = wlpsd_sweep_count / 5;
4860
4861                         if (wlpsd_sweep_count % 5 != 0)
4862                                 wlpsd_sweep_count = (wlpsd_sweep_count /
4863                                                      5 + 1) * 5;
4864 #endif
4865                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4866                                 "xxxxxxxxxxxxxxxx AntennaDetect(), BT_LETxTime=%d,  BT_LECh = %d\n",
4867                                     bt_tx_time, bt_le_channel);
4868                         BTC_TRACE(trace_buf);
4869                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4870                                 "xxxxxxxxxxxxxxxx AntennaDetect(), wlpsd_cent_freq=%d,  wlpsd_offset = %d, wlpsd_span = %d, wlpsd_sweep_count = %d\n",
4871                                     wlpsd_cent_freq,
4872                                     wlpsd_offset,
4873                                     wlpsd_span,
4874                                     BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT);
4875                         BTC_TRACE(trace_buf);
4876
4877                         state = 1;
4878                         break;
4879                 case 1: /* stop coex DM & set antenna path */
4880                         /* Stop Coex DM */
4881                         btcoexist->stop_coex_dm = true;
4882
4883                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4884                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Stop Coex DM!!\n");
4885                         BTC_TRACE(trace_buf);
4886
4887                         /* Set TDMA off,                                 */
4888                         halbtc8723d2ant_ps_tdma(btcoexist, FORCE_EXEC,
4889                                                 false, 0);
4890
4891                         /* Set coex table */
4892                         halbtc8723d2ant_coex_table_with_type(btcoexist,
4893                                                              FORCE_EXEC, 0);
4894
4895                         if (board_info->btdm_ant_pos ==
4896                             BTC_ANTENNA_AT_MAIN_PORT) {
4897                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4898                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Main Port\n");
4899                                 BTC_TRACE(trace_buf);
4900                         } else {
4901                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4902                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna at Aux Port\n");
4903                                 BTC_TRACE(trace_buf);
4904                         }
4905
4906                         /* Set Antenna path, switch WiFi to un-certain antenna port */
4907                         /* Set Antenna Path,  both GNT_WL/GNT_BT = 1, and control by SW */
4908                         halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
4909                                                      FORCE_EXEC,
4910                                              BT_8723D_2ANT_PHASE_ANTENNA_DET);
4911
4912                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4913                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to BT!!\n");
4914                         BTC_TRACE(trace_buf);
4915
4916                         /* Set AFH mask on at WiFi channel 2472MHz +/- 10MHz */
4917                         h2c_parameter[0] = 0x1;
4918                         h2c_parameter[1] = 0xd;
4919                         h2c_parameter[2] = 0x14;
4920
4921                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4922                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d,  Mask=%d\n",
4923                                     h2c_parameter[1],
4924                                     h2c_parameter[2]);
4925                         BTC_TRACE(trace_buf);
4926
4927                         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
4928                                                 h2c_parameter);
4929
4930                         u32tmp = btcoexist->btc_read_2byte(btcoexist, 0x948);
4931                         u32tmp0 = btcoexist->btc_read_4byte(btcoexist, 0x70);
4932                         u32tmp1 = halbtc8723d2ant_ltecoex_indirect_read_reg(
4933                                           btcoexist, 0x38);
4934                         u32tmp2 = halbtc8723d2ant_ltecoex_indirect_read_reg(
4935                                           btcoexist, 0x54);
4936
4937                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4938                                 "[BTCoex], ********** 0x948 = 0x%x, 0x70 = 0x%x, 0x38= 0x%x, 0x54= 0x%x (Before Ant Det)\n",
4939                                     u32tmp, u32tmp0, u32tmp1, u32tmp2);
4940                         BTC_TRACE(trace_buf);
4941
4942                         state = 2;
4943                         break;
4944                 case 2: /* Pre-sweep background psd */
4945                         if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
4946                                      wlpsd_cent_freq, wlpsd_offset, wlpsd_span,
4947                                              BT_8723D_2ANT_ANTDET_PSD_POINTS,
4948                                      BT_8723D_2ANT_ANTDET_PSD_AVGNUM, 3)) {
4949                                 ant_det_finish = false;
4950                                 board_info->btdm_ant_num_by_ant_det = 1;
4951                                 psd_scan->ant_det_result = 8;
4952                                 state = 99;
4953                                 break;
4954                         }
4955
4956                         psd_scan->ant_det_pre_psdscan_peak_val =
4957                                 psd_scan->psd_max_value;
4958
4959                         if (psd_scan->ant_det_pre_psdscan_peak_val >
4960                             (BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4961                              + psd_scan->ant_det_thres_offset) * 100) {
4962                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4963                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Abort Antenna Detection!! becaus background = %d > thres (%d)\n",
4964                                         psd_scan->ant_det_pre_psdscan_peak_val /
4965                                             100,
4966                                         BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4967                                             + psd_scan->ant_det_thres_offset);
4968                                 BTC_TRACE(trace_buf);
4969                                 ant_det_finish = false;
4970                                 board_info->btdm_ant_num_by_ant_det = 1;
4971                                 psd_scan->ant_det_result = 5;
4972                                 state = 99;
4973                         } else {
4974                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4975                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Start Antenna Detection!! becaus background = %d <= thres (%d)\n",
4976                                         psd_scan->ant_det_pre_psdscan_peak_val /
4977                                             100,
4978                                         BT_8723D_2ANT_ANTDET_PSDTHRES_BACKGROUND
4979                                             + psd_scan->ant_det_thres_offset);
4980                                 BTC_TRACE(trace_buf);
4981                                 state = 3;
4982                         }
4983                         break;
4984                 case 3:
4985                         bt_resp = btcoexist->btc_set_bt_ant_detection(
4986                                           btcoexist, (u8)(bt_tx_time & 0xff),
4987                                           (u8)(bt_le_channel & 0xff));
4988
4989                         /* Sync WL Rx PSD with BT Tx time because H2C->Mailbox delay */
4990                         delay_ms(20);
4991
4992                         if (!halbtc8723d2ant_psd_sweep_point(btcoexist,
4993                                              wlpsd_cent_freq, wlpsd_offset,
4994                                                              wlpsd_span,
4995                                              BT_8723D_2ANT_ANTDET_PSD_POINTS,
4996                                              BT_8723D_2ANT_ANTDET_PSD_AVGNUM,
4997                                      BT_8723D_2ANT_ANTDET_PSD_SWWEEPCOUNT)) {
4998                                 ant_det_finish = false;
4999                                 board_info->btdm_ant_num_by_ant_det = 1;
5000                                 psd_scan->ant_det_result = 8;
5001                                 state = 99;
5002                                 break;
5003                         }
5004
5005 #if 1
5006                         psd_scan->ant_det_psd_scan_peak_val =
5007                                 psd_scan->psd_max_value;
5008 #endif
5009 #if 0
5010                         psd_scan->ant_det_psd_scan_peak_val =
5011                                 ((psd_scan->psd_max_value - psd_scan->psd_avg_value) <
5012                                  800) ?
5013                                 psd_scan->psd_max_value : ((
5014                                                 psd_scan->psd_max_value -
5015                                         psd_scan->psd_max_value2 <= 300) ?
5016                                                    psd_scan->psd_avg_value :
5017                                                    psd_scan->psd_max_value2);
5018 #endif
5019                         psd_scan->ant_det_psd_scan_peak_freq =
5020                                 psd_scan->psd_max_value_point;
5021                         state = 4;
5022                         break;
5023                 case 4:
5024
5025                         if (psd_scan->psd_point == 0)
5026                                 delta_freq_per_point = 0;
5027                         else
5028                                 delta_freq_per_point =
5029                                         psd_scan->psd_band_width /
5030                                         psd_scan->psd_point;
5031
5032                         psd_rep1 = psd_scan->ant_det_psd_scan_peak_val / 100;
5033                         psd_rep2 = psd_scan->ant_det_psd_scan_peak_val -
5034                                    psd_rep1 *
5035                                    100;
5036
5037                         freq = ((psd_scan->real_cent_freq - 20) *
5038                                 1000000 + psd_scan->psd_max_value_point
5039                                 * delta_freq_per_point);
5040                         freq1 = freq / 1000000;
5041                         freq2 = freq / 1000 - freq1 * 1000;
5042
5043                         if (freq2 < 100) {
5044                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5045                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.0%d MHz",
5046                                             freq1, freq2);
5047                                 BTC_TRACE(trace_buf);
5048                                 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5049                                            BT_8723D_2ANT_ANTDET_BUF_LEN,
5050                                            "%d.0%d", freq1, freq2);
5051                         } else {
5052                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5053                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Max Value: Freq = %d.%d MHz",
5054                                             freq1, freq2);
5055                                 BTC_TRACE(trace_buf);
5056                                 CL_SPRINTF(psd_scan->ant_det_peak_freq,
5057                                            BT_8723D_2ANT_ANTDET_BUF_LEN,
5058                                            "%d.%d", freq1, freq2);
5059                         }
5060
5061                         if (psd_rep2 < 10) {
5062                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5063                                             ", Value = %d.0%d dB\n",
5064                                             psd_rep1, psd_rep2);
5065                                 BTC_TRACE(trace_buf);
5066                                 CL_SPRINTF(psd_scan->ant_det_peak_val,
5067                                            BT_8723D_2ANT_ANTDET_BUF_LEN,
5068                                            "%d.0%d", psd_rep1, psd_rep2);
5069                         } else {
5070                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5071                                             ", Value = %d.%d dB\n",
5072                                             psd_rep1, psd_rep2);
5073                                 BTC_TRACE(trace_buf);
5074                                 CL_SPRINTF(psd_scan->ant_det_peak_val,
5075                                            BT_8723D_2ANT_ANTDET_BUF_LEN,
5076                                            "%d.%d", psd_rep1, psd_rep2);
5077                         }
5078
5079                         psd_scan->ant_det_is_btreply_available = true;
5080
5081                         if (bt_resp == false) {
5082                                 psd_scan->ant_det_is_btreply_available =
5083                                         false;
5084                                 psd_scan->ant_det_result = 0;
5085                                 ant_det_finish = false;
5086                                 board_info->btdm_ant_num_by_ant_det = 1;
5087                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5088                                         "xxxxxxxxxxxxxxxx AntennaDetect(), BT Response = Fail\n ");
5089                                 BTC_TRACE(trace_buf);
5090                         } else if (psd_scan->ant_det_psd_scan_peak_val >
5091                                 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_BADISOLATION)
5092                                    * 100) {
5093                                 psd_scan->ant_det_result = 1;
5094                                 ant_det_finish = true;
5095                                 board_info->btdm_ant_num_by_ant_det = 2;
5096                                 coex_sta->isolation_btween_wb = (u8)(85 -
5097                                         psd_scan->ant_det_psd_scan_peak_val /
5098                                                              100) & 0xff;
5099                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5100                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Bad-Isolation!!\n");
5101                                 BTC_TRACE(trace_buf);
5102                         } else if (psd_scan->ant_det_psd_scan_peak_val >
5103                                 (BT_8723D_2ANT_ANTDET_PSDTHRES_2ANT_GOODISOLATION
5104                                     + psd_scan->ant_det_thres_offset) * 100) {
5105                                 psd_scan->ant_det_result = 2;
5106                                 ant_det_finish = true;
5107                                 board_info->btdm_ant_num_by_ant_det = 2;
5108                                 coex_sta->isolation_btween_wb = (u8)(85 -
5109                                         psd_scan->ant_det_psd_scan_peak_val /
5110                                                              100) & 0xff;
5111                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5112                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 2-Ant, Good-Isolation!!\n");
5113                                 BTC_TRACE(trace_buf);
5114                         } else if (psd_scan->ant_det_psd_scan_peak_val >
5115                                    (BT_8723D_2ANT_ANTDET_PSDTHRES_1ANT) *
5116                                    100) {
5117                                 psd_scan->ant_det_result = 3;
5118                                 ant_det_finish = true;
5119                                 board_info->btdm_ant_num_by_ant_det = 1;
5120                                 coex_sta->isolation_btween_wb = (u8)(85 -
5121                                         psd_scan->ant_det_psd_scan_peak_val /
5122                                                              100) & 0xff;
5123                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5124                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant!!\n");
5125                                 BTC_TRACE(trace_buf);
5126                         } else {
5127                                 psd_scan->ant_det_result = 4;
5128                                 ant_det_finish = false;
5129                                 board_info->btdm_ant_num_by_ant_det = 1;
5130                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5131                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Detect Result = 1-Ant, un-certainity!!\n");
5132                                 BTC_TRACE(trace_buf);
5133                         }
5134
5135                         state = 99;
5136                         break;
5137                 case 99:  /* restore setup */
5138
5139                         /* Set AFH mask off at WiFi channel 2472MHz +/- 10MHz */
5140                         h2c_parameter[0] = 0x0;
5141                         h2c_parameter[1] = 0x0;
5142                         h2c_parameter[2] = 0x0;
5143
5144                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5145                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Set AFH on, Cent-Ch= %d,  Mask=%d\n",
5146                                     h2c_parameter[1], h2c_parameter[2]);
5147                         BTC_TRACE(trace_buf);
5148
5149                         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3,
5150                                                 h2c_parameter);
5151
5152                         /* Set Antenna Path, GNT_WL/GNT_BT control by PTA */
5153                         /* Set Antenna path, switch WiFi to certain antenna port */
5154                         halbtc8723d2ant_set_ant_path(btcoexist,
5155                                              BTC_ANT_PATH_AUTO, FORCE_EXEC,
5156                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
5157
5158                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5159                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Set Antenna to PTA\n!!");
5160                         BTC_TRACE(trace_buf);
5161
5162                         btcoexist->stop_coex_dm = false;
5163
5164                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5165                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Resume Coex DM\n!!");
5166                         BTC_TRACE(trace_buf);
5167
5168                         outloop = true;
5169                         break;
5170                 }
5171
5172         } while (!outloop);
5173
5174         return ant_det_finish;
5175
5176 }
5177
5178 #ifdef PLATFORM_WINDOWS
5179 #pragma optimize("", off)
5180 #endif
5181 boolean halbtc8723d2ant_psd_antenna_detection_check(IN struct btc_coexist
5182                 *btcoexist)
5183 {
5184         static u32 ant_det_count = 0, ant_det_fail_count = 0;
5185         struct  btc_board_info  *board_info = &btcoexist->board_info;
5186
5187         boolean scan, roam, ant_det_finish = false;
5188
5189         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
5190         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
5191
5192         ant_det_count++;
5193
5194         psd_scan->ant_det_try_count = ant_det_count;
5195
5196         if (scan || roam) {
5197                 ant_det_finish = false;
5198                 psd_scan->ant_det_result = 6;
5199         } else if (coex_sta->bt_disabled) {
5200                 ant_det_finish = false;
5201                 psd_scan->ant_det_result = 11;
5202         } else if (coex_sta->num_of_profile >= 1) {
5203                 ant_det_finish = false;
5204                 psd_scan->ant_det_result = 7;
5205         } else if (
5206                 !psd_scan->ant_det_is_ant_det_available) { /* Antenna initial setup is not ready */
5207                 ant_det_finish = false;
5208                 psd_scan->ant_det_result = 9;
5209         } else if (coex_sta->c2h_bt_inquiry_page) {
5210                 ant_det_finish = false;
5211                 psd_scan->ant_det_result = 10;
5212         } else {
5213
5214                 ant_det_finish = halbtc8723d2ant_psd_antenna_detection(
5215                                          btcoexist);
5216
5217                 delay_ms(psd_scan->ant_det_bt_tx_time);
5218         }
5219
5220
5221         if (!ant_det_finish)
5222                 ant_det_fail_count++;
5223
5224         psd_scan->ant_det_fail_count = ant_det_fail_count;
5225
5226         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5227                 "xxxxxxxxxxxxxxxx AntennaDetect(), result = %d, fail_count = %d, finish = %s\n",
5228                     psd_scan->ant_det_result,
5229                     psd_scan->ant_det_fail_count,
5230                     ant_det_finish == true ? "Yes" : "No");
5231         BTC_TRACE(trace_buf);
5232
5233         return ant_det_finish;
5234
5235 }
5236
5237
5238 /* ************************************************************
5239  * work around function start with wa_halbtc8723d2ant_
5240  * ************************************************************
5241  * ************************************************************
5242  * extern function start with ex_halbtc8723d2ant_
5243  * ************************************************************ */
5244 void ex_halbtc8723d2ant_power_on_setting(IN struct btc_coexist *btcoexist)
5245 {
5246         struct  btc_board_info  *board_info = &btcoexist->board_info;
5247         u8 u8tmp = 0x0;
5248         u16 u16tmp = 0x0;
5249         u32     value = 0;
5250
5251         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5252                 "xxxxxxxxxxxxxxxx Execute 8723d 2-Ant PowerOn Setting xxxxxxxxxxxxxxxx!!\n");
5253         BTC_TRACE(trace_buf);
5254
5255         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5256                     "Ant Det Finish = %s, Ant Det Number  = %d\n",
5257                     (board_info->btdm_ant_det_finish ? "Yes" : "No"),
5258                     board_info->btdm_ant_num_by_ant_det);
5259         BTC_TRACE(trace_buf);
5260
5261
5262         btcoexist->stop_coex_dm = true;
5263         psd_scan->ant_det_is_ant_det_available = false;
5264
5265         /* enable BB, REG_SYS_FUNC_EN such that we can write BB Register correctly. */
5266         u16tmp = btcoexist->btc_read_2byte(btcoexist, 0x2);
5267         btcoexist->btc_write_2byte(btcoexist, 0x2, u16tmp | BIT(0) | BIT(1));
5268
5269
5270         /* Local setting bit define */
5271         /*      BIT0: "0" for no antenna inverse; "1" for antenna inverse  */
5272         /*      BIT1: "0" for internal switch; "1" for external switch */
5273         /*      BIT2: "0" for one antenna; "1" for two antenna */
5274         /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5275
5276         /* Set path control to WL */
5277         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x80, 0x1);
5278         btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
5279
5280         /* Check efuse 0xc3[6] for Single Antenna Path */
5281         if (board_info->single_ant_path == 0) {
5282                 /* set to S1 */
5283                 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
5284                 u8tmp = 4;
5285                 value = 1;
5286         } else if (board_info->single_ant_path == 1) {
5287                 /* set to S0 */
5288                 board_info->btdm_ant_pos = BTC_ANTENNA_AT_AUX_PORT;
5289                 u8tmp = 5;
5290                 value = 0;
5291         }
5292
5293         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5294                 "[BTCoex], ********** (Power On) single_ant_path  = %d, btdm_ant_pos = %d **********\n",
5295                     board_info->single_ant_path , board_info->btdm_ant_pos);
5296         BTC_TRACE(trace_buf);
5297
5298         /* Set Antenna Path to BT side */
5299         halbtc8723d2ant_set_ant_path(btcoexist,
5300                                      BTC_ANT_PATH_AUTO,
5301                                      FORCE_EXEC,
5302                                      BT_8723D_1ANT_PHASE_COEX_POWERON);
5303
5304         /* Write Single Antenna Position to Registry to tell BT for 872db. This line can be removed
5305         since BT EFuse also add "single antenna position" in EFuse for 8723d*/
5306         btcoexist->btc_set(btcoexist, BTC_SET_ACT_ANTPOSREGRISTRY_CTRL,
5307                            &value);
5308
5309         /* Save"single antenna position" info in Local register setting for FW reading, because FW may not ready at  power on */
5310         if (btcoexist->chip_interface == BTC_INTF_PCI)
5311                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0, u8tmp);
5312         else if (btcoexist->chip_interface == BTC_INTF_USB)
5313                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5314         else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5315                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60, u8tmp);
5316
5317         /* enable GNT_WL/GNT_BT debug signal to GPIO14/15 */
5318         halbtc8723d2ant_enable_gnt_to_gpio(btcoexist, true);
5319
5320         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5321                 "[BTCoex], **********  LTE coex Reg 0x38 (Power-On) = 0x%x**********\n",
5322                     halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38));
5323         BTC_TRACE(trace_buf);
5324
5325         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5326                 "[BTCoex], **********  MAC Reg 0x70/ BB Reg 0x948 (Power-On) = 0x%x / 0x%x**********\n",
5327                     btcoexist->btc_read_4byte(btcoexist, 0x70),
5328                     btcoexist->btc_read_2byte(btcoexist, 0x948));
5329         BTC_TRACE(trace_buf);
5330 }
5331
5332 void ex_halbtc8723d2ant_pre_load_firmware(IN struct btc_coexist *btcoexist)
5333 {
5334         struct  btc_board_info  *board_info = &btcoexist->board_info;
5335         u8 u8tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
5336
5337         /* */
5338         /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
5339         /* Local setting bit define */
5340         /*      BIT0: "0" for no antenna inverse; "1" for antenna inverse  */
5341         /*      BIT1: "0" for internal switch; "1" for external switch */
5342         /*      BIT2: "0" for one antenna; "1" for two antenna */
5343         /* NOTE: here default all internal switch and 1-antenna ==> BIT1=0 and BIT2=0 */
5344         if (btcoexist->chip_interface == BTC_INTF_USB) {
5345                 /* fixed at S0 for USB interface */
5346                 u8tmp |= 0x1;   /* antenna inverse */
5347                 btcoexist->btc_write_local_reg_1byte(btcoexist, 0xfe08, u8tmp);
5348         } else {
5349                 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */
5350                 if (board_info->single_ant_path == 0) {
5351                 } else if (board_info->single_ant_path == 1) {
5352                         /* set to S0 */
5353                         u8tmp |= 0x1;   /* antenna inverse */
5354                 }
5355
5356                 if (btcoexist->chip_interface == BTC_INTF_PCI)
5357                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x3e0,
5358                                                              u8tmp);
5359                 else if (btcoexist->chip_interface == BTC_INTF_SDIO)
5360                         btcoexist->btc_write_local_reg_1byte(btcoexist, 0x60,
5361                                                              u8tmp);
5362         }
5363 }
5364
5365
5366 void ex_halbtc8723d2ant_init_hw_config(IN struct btc_coexist *btcoexist,
5367                                        IN boolean wifi_only)
5368 {
5369         halbtc8723d2ant_init_hw_config(btcoexist, wifi_only);
5370 }
5371
5372 void ex_halbtc8723d2ant_init_coex_dm(IN struct btc_coexist *btcoexist)
5373 {
5374
5375         halbtc8723d2ant_init_coex_dm(btcoexist);
5376 }
5377
5378 void ex_halbtc8723d2ant_display_coex_info(IN struct btc_coexist *btcoexist)
5379 {
5380         struct  btc_board_info          *board_info = &btcoexist->board_info;
5381         struct  btc_bt_link_info        *bt_link_info = &btcoexist->bt_link_info;
5382         u8                              *cli_buf = btcoexist->cli_buf;
5383         u8                              u8tmp[4], i, ps_tdma_case = 0;
5384         u32                             u32tmp[4];
5385         u16                             u16tmp[4];
5386         u32                             fa_ofdm, fa_cck, cca_ofdm, cca_cck, bt_coex_ver = 0;
5387         u32                             fw_ver = 0, bt_patch_ver = 0;
5388         static u8                       pop_report_in_10s = 0;
5389         u32                     phyver = 0;
5390         boolean                 lte_coex_on = false;
5391
5392         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5393                    "\r\n ============[BT Coexist info]============");
5394         CL_PRINTF(cli_buf);
5395
5396         if (btcoexist->manual_control) {
5397                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5398                         "\r\n ============[Under Manual Control]============");
5399                 CL_PRINTF(cli_buf);
5400                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5401                            "\r\n ==========================================");
5402                 CL_PRINTF(cli_buf);
5403         }
5404
5405         if (psd_scan->ant_det_try_count == 0) {
5406                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s",
5407                            "Ant PG Num/ Mech/ Pos",
5408                            board_info->pg_ant_num, board_info->btdm_ant_num,
5409                            (board_info->btdm_ant_pos == 1 ? "S1" : "S0"));
5410                 CL_PRINTF(cli_buf);
5411         } else {
5412                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5413                         "\r\n %-35s = %d/ %d/ %s  (retry=%d/fail=%d/result=%d)",
5414                            "Ant PG Num/ Mech(Ant_Det)/ Pos",
5415                            board_info->pg_ant_num,
5416                            board_info->btdm_ant_num_by_ant_det,
5417                            (board_info->btdm_ant_pos == 1 ? "S1" : "S0"),
5418                            psd_scan->ant_det_try_count,
5419                            psd_scan->ant_det_fail_count,
5420                            psd_scan->ant_det_result);
5421                 CL_PRINTF(cli_buf);
5422
5423                 if (board_info->btdm_ant_det_finish) {
5424
5425                         if (psd_scan->ant_det_result != 12)
5426                                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5427                                            "\r\n %-35s = %s",
5428                                            "Ant Det PSD Value",
5429                                            psd_scan->ant_det_peak_val);
5430                         else
5431                                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5432                                            "\r\n %-35s = %d",
5433                                            "Ant Det PSD Value",
5434                                            psd_scan->ant_det_psd_scan_peak_val
5435                                            / 100);
5436                         CL_PRINTF(cli_buf);
5437                 }
5438         }
5439
5440         if (board_info->ant_det_result_five_complete) {
5441                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5442                            "\r\n %-35s = %d/ %d",
5443                            "AntDet(Registry) Num/PSD Value",
5444                            board_info->btdm_ant_num_by_ant_det,
5445                            (board_info->antdetval & 0x7f));
5446                 CL_PRINTF(cli_buf);
5447         }
5448
5449
5450         bt_patch_ver = btcoexist->bt_info.bt_get_fw_ver;
5451         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
5452         phyver = btcoexist->btc_get_bt_phydm_version(btcoexist);
5453
5454         bt_coex_ver = coex_sta->bt_coex_supported_version & 0xff;
5455
5456         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5457                                 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
5458                                 "CoexVer WL/  BT_Desired/ BT_Report",
5459                                 glcoex_ver_date_8723d_2ant, glcoex_ver_8723d_2ant,
5460                                 glcoex_ver_btdesired_8723d_2ant,
5461                                 bt_coex_ver,
5462                                 (bt_coex_ver == 0xff ? "Unknown" :
5463                                 (coex_sta->bt_disabled ? "BT-disable" :
5464                                 (bt_coex_ver >= glcoex_ver_btdesired_8723d_2ant ?
5465                                 "Match" : "Mis-Match"))));
5466         CL_PRINTF(cli_buf);
5467
5468         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5469                    "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
5470                    "W_FW/ B_FW/ Phy/ Kt",
5471                    fw_ver, bt_patch_ver, phyver,
5472                    coex_sta->cut_version + 65);
5473         CL_PRINTF(cli_buf);
5474
5475         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
5476                    "Wifi channel informed to BT",
5477                    coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
5478                    coex_dm->wifi_chnl_info[2]);
5479         CL_PRINTF(cli_buf);
5480
5481         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d ",
5482                    "Isolation/WL_Thres/BT_Thres",
5483                    coex_sta->isolation_btween_wb,
5484                    coex_sta->wifi_coex_thres,
5485                    coex_sta->bt_coex_thres);
5486         CL_PRINTF(cli_buf);
5487
5488         /* wifi status */
5489         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5490                    "============[Wifi Status]============");
5491         CL_PRINTF(cli_buf);
5492         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_WIFI_STATUS);
5493
5494         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5495                    "============[BT Status]============");
5496         CL_PRINTF(cli_buf);
5497
5498         pop_report_in_10s++;
5499         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5500                    "\r\n %-35s = [%s/ %d dBm/ %d/ %d] ",
5501                    "BT [status/ rssi/ retryCnt/ popCnt]",
5502                    ((coex_sta->bt_disabled) ? ("disabled") :    ((
5503                            coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page")
5504                            : ((BT_8723D_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
5505                                coex_dm->bt_status) ? "non-connected idle" :
5506                 ((BT_8723D_2ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)
5507                                        ? "connected-idle" : "busy")))),
5508                    coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
5509                    coex_sta->pop_event_cnt);
5510         CL_PRINTF(cli_buf);
5511
5512         if (pop_report_in_10s >= 5) {
5513                 coex_sta->pop_event_cnt = 0;
5514                 pop_report_in_10s = 0;
5515         }
5516
5517
5518         if (coex_sta->num_of_profile != 0)
5519                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5520                            "\r\n %-35s = %s%s%s%s%s",
5521                            "Profiles",
5522                            ((bt_link_info->a2dp_exist) ? "A2DP," : ""),
5523                            ((bt_link_info->sco_exist) ?  "SCO," : ""),
5524                            ((bt_link_info->hid_exist) ?
5525                             ((coex_sta->hid_busy_num >= 2) ? "HID(4/18)," :
5526                              "HID(2/18),") : ""),
5527                            ((bt_link_info->pan_exist) ?  "PAN," : ""),
5528                            ((coex_sta->voice_over_HOGP) ? "Voice" : ""));
5529         else
5530                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5531                            "\r\n %-35s = None",
5532                            "Profiles");
5533
5534         CL_PRINTF(cli_buf);
5535
5536
5537         if (bt_link_info->a2dp_exist) {
5538                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s",
5539                            "A2DP Rate/Bitpool/Auto_Slot",
5540                            ((coex_sta->is_A2DP_3M) ? "3M" : "No_3M"),
5541                            coex_sta->a2dp_bit_pool,
5542                            ((coex_sta->is_autoslot) ? "On" : "Off")
5543                           );
5544                 CL_PRINTF(cli_buf);
5545         }
5546
5547         if (bt_link_info->hid_exist) {
5548                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5549                            "HID PairNum/Forbid_Slot",
5550                            coex_sta->hid_pair_cnt,
5551                            coex_sta->forbidden_slot
5552                           );
5553                 CL_PRINTF(cli_buf);
5554         }
5555
5556         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s/ 0x%x/ 0x%x",
5557                         "Role/IgnWlanAct/Feature/BLEScan",
5558                         ((bt_link_info->slave_role) ? "Slave" : "Master"),
5559                         ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
5560                         coex_sta->bt_coex_supported_feature,
5561                         coex_sta->bt_ble_scan_type);
5562         CL_PRINTF(cli_buf);
5563
5564         if ((coex_sta->bt_ble_scan_type & 0x7) != 0x0) {
5565                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5566                         "\r\n %-35s = 0x%08x/ 0x%08x/ 0x%08x",
5567                         "BLEScan Intv-Win TV/Init/Ble",
5568                         (coex_sta->bt_ble_scan_type & 0x1 ?
5569                         coex_sta->bt_ble_scan_para[0] : 0x0),
5570                         (coex_sta->bt_ble_scan_type & 0x2 ?
5571                         coex_sta->bt_ble_scan_para[1] : 0x0),
5572                         (coex_sta->bt_ble_scan_type & 0x4 ?
5573                         coex_sta->bt_ble_scan_para[2] : 0x0));
5574
5575                 CL_PRINTF(cli_buf);
5576         }
5577
5578         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
5579                    "ReInit/ReLink/IgnWlact/Page/NameReq",
5580                    coex_sta->cnt_ReInit,
5581                    coex_sta->cnt_setupLink,
5582                    coex_sta->cnt_IgnWlanAct,
5583                    coex_sta->cnt_Page,
5584                    coex_sta->cnt_RemoteNameReq
5585                   );
5586         CL_PRINTF(cli_buf);
5587
5588         halbtc8723d2ant_read_score_board(btcoexist,     &u16tmp[0]);
5589
5590         if ((coex_sta->bt_reg_vendor_ae == 0xffff) ||
5591             (coex_sta->bt_reg_vendor_ac == 0xffff))
5592                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = x/ x/ %04x",
5593                            "0xae[4]/0xac[1:0]/Scoreboard", u16tmp[0]);
5594         else
5595                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5596                            "\r\n %-35s = 0x%x/ 0x%x/ %04x",
5597                            "0xae[4]/0xac[1:0]/Scoreboard",
5598                            ((coex_sta->bt_reg_vendor_ae & BIT(4)) >> 4),
5599                            coex_sta->bt_reg_vendor_ac & 0x3, u16tmp[0]);
5600         CL_PRINTF(cli_buf);
5601
5602         if (coex_sta->num_of_profile > 0) {
5603
5604                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5605                         "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
5606                         "AFH MAP",
5607                         coex_sta->bt_afh_map[0],
5608                         coex_sta->bt_afh_map[1],
5609                         coex_sta->bt_afh_map[2],
5610                         coex_sta->bt_afh_map[3],
5611                         coex_sta->bt_afh_map[4],
5612                         coex_sta->bt_afh_map[5],
5613                         coex_sta->bt_afh_map[6],
5614                         coex_sta->bt_afh_map[7],
5615                         coex_sta->bt_afh_map[8],
5616                         coex_sta->bt_afh_map[9]
5617                            );
5618                 CL_PRINTF(cli_buf);
5619         }
5620
5621         for (i = 0; i < BT_INFO_SRC_8723D_2ANT_MAX; i++) {
5622                 if (coex_sta->bt_info_c2h_cnt[i]) {
5623                         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5624                                 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
5625                                    glbt_info_src_8723d_2ant[i],
5626                                    coex_sta->bt_info_c2h[i][0],
5627                                    coex_sta->bt_info_c2h[i][1],
5628                                    coex_sta->bt_info_c2h[i][2],
5629                                    coex_sta->bt_info_c2h[i][3],
5630                                    coex_sta->bt_info_c2h[i][4],
5631                                    coex_sta->bt_info_c2h[i][5],
5632                                    coex_sta->bt_info_c2h[i][6],
5633                                    coex_sta->bt_info_c2h_cnt[i]);
5634                         CL_PRINTF(cli_buf);
5635                 }
5636         }
5637
5638         /* Sw mechanism  */
5639         if (btcoexist->manual_control)
5640                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5641                         "============[mechanism] (before Manual)============");
5642         else
5643                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5644                            "============[Mechanism]============");
5645
5646         CL_PRINTF(cli_buf);
5647
5648
5649         ps_tdma_case = coex_dm->cur_ps_tdma;
5650
5651         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5652                    "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, %s, %s)",
5653                    "TDMA",
5654                    coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
5655                    coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
5656                    coex_dm->ps_tdma_para[4], ps_tdma_case,
5657                    (coex_dm->cur_ps_tdma_on ? "TDMA On" : "TDMA Off"),
5658                    (coex_dm->is_switch_to_1dot5_ant ? "1.5Ant" : "2Ant"));
5659         CL_PRINTF(cli_buf);
5660
5661         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
5662         u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
5663         u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
5664         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5665                    "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
5666                    "Table/0x6c0/0x6c4/0x6c8",
5667                    coex_sta->coex_table_type, u32tmp[0], u32tmp[1], u32tmp[2]);
5668         CL_PRINTF(cli_buf);
5669
5670         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
5671         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6cc);
5672         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5673                    "\r\n %-35s = 0x%x/ 0x%x",
5674                    "0x778/0x6cc",
5675                    u8tmp[0], u32tmp[0]);
5676         CL_PRINTF(cli_buf);
5677
5678         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5679                    "AntDiv/ ForceLPS",
5680                    ((board_info->ant_div_cfg) ? "On" : "Off"),
5681                    ((coex_sta->force_lps_on) ? "On" : "Off"));
5682         CL_PRINTF(cli_buf);
5683
5684         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5685                    "WL_DACSwing/ BT_Dec_Pwr", coex_dm->cur_fw_dac_swing_lvl,
5686                    coex_dm->cur_bt_dec_pwr_lvl);
5687         CL_PRINTF(cli_buf);
5688
5689         u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5690         lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ?  true : false;
5691
5692         if (lte_coex_on) {
5693
5694                 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5695                                 0xa0);
5696                 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5697                                 0xa4);
5698
5699                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5700                            "LTE Coex  Table W_L/B_L",
5701                            u32tmp[0] & 0xffff, u32tmp[1] & 0xffff);
5702                 CL_PRINTF(cli_buf);
5703
5704                 u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5705                                 0xa8);
5706                 u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5707                                 0xac);
5708                 u32tmp[2] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5709                                 0xb0);
5710                 u32tmp[3] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist,
5711                                 0xb4);
5712
5713                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5714                            "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5715                            "LTE Break Table W_L/B_L/L_W/L_B",
5716                            u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
5717                            u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
5718                 CL_PRINTF(cli_buf);
5719
5720         }
5721
5722         /* Hw setting            */
5723         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
5724                    "============[Hw setting]============");
5725         CL_PRINTF(cli_buf);
5726         /*
5727                 u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
5728                 u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
5729                 u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
5730                 u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
5731                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
5732                            "0x430/0x434/0x42a/0x456",
5733                            u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0]);
5734                 CL_PRINTF(cli_buf);
5735         */
5736         u32tmp[0] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x38);
5737         u32tmp[1] = halbtc8723d2ant_ltecoex_indirect_read_reg(btcoexist, 0x54);
5738         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x73);
5739
5740         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
5741                    "LTE Coex/Path Owner",
5742                    ((lte_coex_on) ? "On" : "Off") ,
5743                    ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
5744         CL_PRINTF(cli_buf);
5745
5746         if (lte_coex_on) {
5747                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5748                            "\r\n %-35s = %d/ %d/ %d/ %d",
5749                            "LTE 3Wire/OPMode/UART/UARTMode",
5750                            (int)((u32tmp[0] & BIT(6)) >> 6),
5751                            (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
5752                            (int)((u32tmp[0] & BIT(3)) >> 3),
5753                            (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
5754                 CL_PRINTF(cli_buf);
5755
5756                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5757                            "LTE_Busy/UART_Busy",
5758                         (int)((u32tmp[1] & BIT(1)) >> 1), (int)(u32tmp[1] & BIT(0)));
5759                 CL_PRINTF(cli_buf);
5760         }
5761
5762         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5763                            "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s %d",
5764                            "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
5765                            ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
5766                            ((u32tmp[0] & BIT(8)) ?      "SW" : "HW"),
5767                            ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
5768                            ((u32tmp[0] & BIT(10)) ?  "SW" : "HW"),
5769                            ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
5770                            coex_sta->gnt_error_cnt);
5771                 CL_PRINTF(cli_buf);
5772
5773                 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
5774                    "GNT_WL/GNT_BT",
5775                    (int)((u32tmp[1] & BIT(2)) >> 2),
5776                    (int)((u32tmp[1] & BIT(3)) >> 3));
5777         CL_PRINTF(cli_buf);
5778
5779         u16tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x948);
5780         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
5781
5782         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
5783                    "0x948/0x67[7]",
5784                    u16tmp[0], (int)((u8tmp[0] & BIT(7)) >> 7));
5785         CL_PRINTF(cli_buf);
5786
5787         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x964);
5788         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x864);
5789         u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0xab7);
5790         u8tmp[3] = btcoexist->btc_read_1byte(btcoexist, 0xa01);
5791
5792         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5793                    "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5794                    "0x964[1]/0x864[0]/0xab7[5]/0xa01[7]",
5795                    (int)((u8tmp[0] & BIT(1)) >> 1), (int)((u8tmp[1] & BIT(0))),
5796                    (int)((u8tmp[2] & BIT(3)) >> 3),
5797                    (int)((u8tmp[3] & BIT(7)) >> 7));
5798         CL_PRINTF(cli_buf);
5799
5800
5801         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x4c6);
5802         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
5803         u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x45e);
5804
5805         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
5806                    "0x4c6[4]/0x40[5]/0x45e[3](TxRetry)",
5807                    (int)((u8tmp[0] & BIT(4)) >> 4),
5808                    (int)((u8tmp[1] & BIT(5)) >> 5),
5809                    (int)((u8tmp[2] & BIT(3)) >> 3));
5810         CL_PRINTF(cli_buf);
5811
5812         u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
5813         u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
5814         u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x953);
5815         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ %s",
5816                    "0x550/0x522/4-RxAGC",
5817                    u32tmp[0], u8tmp[0], (u8tmp[1] & 0x2) ? "On" : "Off");
5818         CL_PRINTF(cli_buf);
5819
5820         fa_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_OFDM);
5821         fa_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_FA_CCK);
5822         cca_ofdm = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_OFDM);
5823         cca_cck = btcoexist->btc_phydm_query_PHY_counter(btcoexist, PHYDM_INFO_CCA_CCK);
5824
5825         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
5826                    "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
5827                    "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA",
5828                    cca_cck, fa_cck, cca_ofdm, fa_ofdm);
5829         CL_PRINTF(cli_buf);
5830
5831 #if 1
5832         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
5833                    "CRC_OK CCK/11g/11n/11n-agg",
5834                    coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
5835                    coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
5836         CL_PRINTF(cli_buf);
5837
5838         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
5839                    "CRC_Err CCK/11g/11n/11n-agg",
5840                    coex_sta->crc_err_cck, coex_sta->crc_err_11g,
5841                    coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
5842         CL_PRINTF(cli_buf);
5843 #endif
5844
5845         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
5846                    "WlHiPri/ Locking/ Locked/ Noisy",
5847                    (coex_sta->wifi_is_high_pri_task ? "Yes" : "No"),
5848                    (coex_sta->cck_lock ? "Yes" : "No"),
5849                    (coex_sta->cck_ever_lock ? "Yes" : "No"),
5850                    coex_sta->wl_noisy_level);
5851         CL_PRINTF(cli_buf);
5852
5853         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
5854                    "0x770(Hi-pri rx/tx)",
5855                    coex_sta->high_priority_rx, coex_sta->high_priority_tx,
5856                    (coex_sta->is_hiPri_rx_overhead ? "(scan overhead!!)" : ""));
5857         CL_PRINTF(cli_buf);
5858
5859         CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
5860                    "0x774(Lo-pri rx/tx)",
5861                    coex_sta->low_priority_rx, coex_sta->low_priority_tx,
5862                    (bt_link_info->slave_role ? "(Slave!!)" : (
5863                    coex_sta->is_tdma_btautoslot_hang ? "(auto-slot hang!!)" : "")));
5864         CL_PRINTF(cli_buf);
5865
5866         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
5867 }
5868
5869
5870 void ex_halbtc8723d2ant_ips_notify(IN struct btc_coexist *btcoexist, IN u8 type)
5871 {
5872         if (btcoexist->manual_control ||        btcoexist->stop_coex_dm)
5873                 return;
5874
5875         if (BTC_IPS_ENTER == type) {
5876                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5877                             "[BTCoex], IPS ENTER notify\n");
5878                 BTC_TRACE(trace_buf);
5879                 coex_sta->under_ips = true;
5880                 coex_sta->under_lps = false;
5881
5882                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5883                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
5884
5885                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5886                                         BT_8723D_2ANT_SCOREBOARD_ONOFF, false);
5887
5888                 halbtc8723d2ant_set_ant_path(btcoexist,
5889                                              BTC_ANT_PATH_AUTO,
5890                                              FORCE_EXEC,
5891                                              BT_8723D_2ANT_PHASE_WLAN_OFF);
5892
5893                 halbtc8723d2ant_action_coex_all_off(btcoexist);
5894         } else if (BTC_IPS_LEAVE == type) {
5895                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5896                             "[BTCoex], IPS LEAVE notify\n");
5897                 BTC_TRACE(trace_buf);
5898                 coex_sta->under_ips = false;
5899
5900                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5901                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5902
5903                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5904                                         BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
5905
5906                 halbtc8723d2ant_init_hw_config(btcoexist, false);
5907                 halbtc8723d2ant_init_coex_dm(btcoexist);
5908                 halbtc8723d2ant_query_bt_info(btcoexist);
5909         }
5910 }
5911
5912 void ex_halbtc8723d2ant_lps_notify(IN struct btc_coexist *btcoexist, IN u8 type)
5913 {
5914         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
5915                 return;
5916
5917         if (BTC_LPS_ENABLE == type) {
5918                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5919                             "[BTCoex], LPS ENABLE notify\n");
5920                 BTC_TRACE(trace_buf);
5921                 coex_sta->under_lps = true;
5922                 coex_sta->under_ips = false;
5923
5924                 if (coex_sta->force_lps_on == true) { /* LPS No-32K */
5925                         /* Write WL "Active" in Score-board for PS-TDMA */
5926                         halbtc8723d2ant_post_state_to_bt(btcoexist,
5927                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5928
5929                 } else { /* LPS-32K, need check if this h2c 0x71 can work?? (2015/08/28) */
5930                         /* Write WL "Non-Active" in Score-board for Native-PS */
5931                         halbtc8723d2ant_post_state_to_bt(btcoexist,
5932                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
5933                 }
5934
5935
5936         } else if (BTC_LPS_DISABLE == type) {
5937                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5938                             "[BTCoex], LPS DISABLE notify\n");
5939                 BTC_TRACE(trace_buf);
5940                 coex_sta->under_lps = false;
5941
5942                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5943                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5944         }
5945 }
5946
5947 void ex_halbtc8723d2ant_scan_notify(IN struct btc_coexist *btcoexist,
5948                                     IN u8 type)
5949 {
5950         u32     u32tmp;
5951         u8      u8tmpa, u8tmpb;
5952         boolean wifi_connected = false;
5953
5954
5955         if (btcoexist->manual_control ||
5956             btcoexist->stop_coex_dm)
5957                 return;
5958
5959         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
5960                            &wifi_connected);
5961
5962         /*  this can't be removed for RF off_on event, or BT would dis-connect */
5963         halbtc8723d2ant_query_bt_info(btcoexist);
5964
5965         if (BTC_SCAN_START == type) {
5966
5967                 if (!wifi_connected)
5968                         coex_sta->wifi_is_high_pri_task = true;
5969
5970                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5971                             "[BTCoex], SCAN START notify\n");
5972                 BTC_TRACE(trace_buf);
5973
5974                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5975                                          BT_8723D_2ANT_SCOREBOARD_SCAN, true);
5976                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5977                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
5978
5979                 halbtc8723d2ant_set_ant_path(btcoexist,
5980                                              BTC_ANT_PATH_AUTO,
5981                                              FORCE_EXEC,
5982                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
5983
5984                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
5985
5986         } else if (BTC_SCAN_FINISH == type) {
5987
5988                 coex_sta->wifi_is_high_pri_task = false;
5989
5990                 btcoexist->btc_get(btcoexist, BTC_GET_U1_AP_NUM,
5991                                    &coex_sta->scan_ap_num);
5992
5993                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5994                             "[BTCoex], SCAN FINISH notify  (Scan-AP = %d)\n",
5995                             coex_sta->scan_ap_num);
5996                 BTC_TRACE(trace_buf);
5997
5998                 halbtc8723d2ant_post_state_to_bt(btcoexist,
5999                                          BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6000
6001                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6002         }
6003
6004 }
6005
6006 void ex_halbtc8723d2ant_connect_notify(IN struct btc_coexist *btcoexist,
6007                                        IN u8 type)
6008 {
6009         if (btcoexist->manual_control ||
6010             btcoexist->stop_coex_dm)
6011                 return;
6012
6013         if (BTC_ASSOCIATE_START == type) {
6014
6015                 coex_sta->wifi_is_high_pri_task = true;
6016
6017                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6018                             "[BTCoex], CONNECT START notify\n");
6019                 BTC_TRACE(trace_buf);
6020
6021                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6022                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6023                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6024                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6025
6026                 halbtc8723d2ant_set_ant_path(btcoexist,
6027                                              BTC_ANT_PATH_AUTO,
6028                                              FORCE_EXEC,
6029                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
6030
6031                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6032                 /* To keep TDMA case during connect process,
6033                 to avoid changed by Btinfo and runcoexmechanism */
6034                 coex_sta->freeze_coexrun_by_btinfo = true;
6035
6036                 coex_dm->arp_cnt = 0;
6037
6038         } else if (BTC_ASSOCIATE_FINISH == type) {
6039
6040                 coex_sta->wifi_is_high_pri_task = false;
6041                 coex_sta->freeze_coexrun_by_btinfo = false;
6042
6043                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6044                             "[BTCoex], CONNECT FINISH notify\n");
6045                 BTC_TRACE(trace_buf);
6046
6047                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6048         }
6049 }
6050
6051 void ex_halbtc8723d2ant_media_status_notify(IN struct btc_coexist *btcoexist,
6052                 IN u8 type)
6053 {
6054         u8                      h2c_parameter[3] = {0};
6055         u32                     wifi_bw;
6056         u8                      wifi_central_chnl;
6057         u8                      ap_num = 0;
6058         boolean         wifi_under_b_mode = false;
6059
6060         if (btcoexist->manual_control ||
6061             btcoexist->stop_coex_dm)
6062                 return;
6063
6064         if (BTC_MEDIA_CONNECT == type) {
6065
6066                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6067                             "[BTCoex], MEDIA connect notify\n");
6068                 BTC_TRACE(trace_buf);
6069
6070                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6071                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6072
6073                 halbtc8723d2ant_set_ant_path(btcoexist,
6074                                              BTC_ANT_PATH_AUTO,
6075                                              FORCE_EXEC,
6076                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
6077
6078                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_B_MODE,
6079                                    &wifi_under_b_mode);
6080
6081                 /* Set CCK Tx/Rx high Pri except 11b mode */
6082                 if (wifi_under_b_mode) {
6083                         btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6084                                                    0x00); /* CCK Tx */
6085                         btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6086                                                    0x00); /* CCK Rx */
6087                 } else {
6088
6089                         btcoexist->btc_write_1byte(btcoexist, 0x6cd,
6090                                                    0x00); /* CCK Tx */
6091                         btcoexist->btc_write_1byte(btcoexist, 0x6cf,
6092                                                    0x10); /* CCK Rx */
6093                 }
6094
6095         } else {
6096                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6097                             "[BTCoex], MEDIA disconnect notify\n");
6098                 BTC_TRACE(trace_buf);
6099
6100                 btcoexist->btc_write_1byte(btcoexist, 0x6cd, 0x0); /* CCK Tx */
6101                 btcoexist->btc_write_1byte(btcoexist, 0x6cf, 0x0); /* CCK Rx */
6102
6103                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6104                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
6105         }
6106
6107
6108         halbtc8723d2ant_update_wifi_channel_info(btcoexist, type);
6109 }
6110
6111 void ex_halbtc8723d2ant_specific_packet_notify(IN struct btc_coexist *btcoexist,
6112                 IN u8 type)
6113 {
6114         boolean under_4way = false;
6115
6116         if (btcoexist->manual_control ||
6117             btcoexist->stop_coex_dm)
6118                 return;
6119
6120         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
6121                            &under_4way);
6122
6123         if (under_4way) {
6124
6125                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6126                             "[BTCoex], specific Packet ---- under_4way!!\n");
6127                 BTC_TRACE(trace_buf);
6128
6129                 coex_sta->wifi_is_high_pri_task = true;
6130                 coex_sta->specific_pkt_period_cnt = 2;
6131
6132         } else if (BTC_PACKET_ARP == type) {
6133
6134                 coex_dm->arp_cnt++;
6135                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6136                             "[BTCoex], specific Packet ARP notify -cnt = %d\n",
6137                             coex_dm->arp_cnt);
6138                 BTC_TRACE(trace_buf);
6139
6140         } else {
6141
6142                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6143                         "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
6144                             type);
6145                 BTC_TRACE(trace_buf);
6146
6147                 coex_sta->wifi_is_high_pri_task = true;
6148                 coex_sta->specific_pkt_period_cnt = 2;
6149         }
6150
6151         if (coex_sta->wifi_is_high_pri_task) {
6152                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6153                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6154                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6155         }
6156
6157 }
6158
6159 void ex_halbtc8723d2ant_bt_info_notify(IN struct btc_coexist *btcoexist,
6160                                        IN u8 *tmp_buf, IN u8 length)
6161 {
6162         u8                      i, rsp_source = 0;
6163         boolean         wifi_connected = false;
6164         boolean wifi_scan = false, wifi_link = false, wifi_roam = false,
6165                     wifi_busy = false;
6166
6167         if (psd_scan->is_AntDet_running == true) {
6168                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6169                         "[BTCoex], bt_info_notify return for AntDet is running\n");
6170                 BTC_TRACE(trace_buf);
6171                 return;
6172         }
6173
6174         rsp_source = tmp_buf[0] & 0xf;
6175         if (rsp_source >= BT_INFO_SRC_8723D_2ANT_MAX)
6176                 rsp_source = BT_INFO_SRC_8723D_2ANT_WIFI_FW;
6177         coex_sta->bt_info_c2h_cnt[rsp_source]++;
6178
6179         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6180                     "[BTCoex], Bt_info[%d], len=%d, data=[", rsp_source,
6181                     length);
6182         BTC_TRACE(trace_buf);
6183
6184         for (i = 0; i < length; i++) {
6185                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
6186
6187                 if (i == length - 1) {
6188                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x]\n",
6189                                     tmp_buf[i]);
6190                         BTC_TRACE(trace_buf);
6191                 } else {
6192                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "0x%02x, ",
6193                                     tmp_buf[i]);
6194                         BTC_TRACE(trace_buf);
6195                 }
6196         }
6197
6198         coex_sta->bt_info = coex_sta->bt_info_c2h[rsp_source][1];
6199         coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
6200         coex_sta->bt_info_ext2 = coex_sta->bt_info_c2h[rsp_source][5];
6201
6202         if (BT_INFO_SRC_8723D_2ANT_WIFI_FW != rsp_source) {
6203
6204                 /* if 0xff, it means BT is under WHCK test */
6205                 coex_sta->bt_whck_test = ((coex_sta->bt_info == 0xff) ? true :
6206                                           false);
6207
6208                 coex_sta->bt_create_connection = ((
6209                         coex_sta->bt_info_c2h[rsp_source][2] & 0x80) ? true :
6210                                                   false);
6211
6212                 /* unit: %, value-100 to translate to unit: dBm */
6213                 coex_sta->bt_rssi = coex_sta->bt_info_c2h[rsp_source][3] * 2 +
6214                                     10;
6215
6216                 coex_sta->c2h_bt_remote_name_req = ((
6217                         coex_sta->bt_info_c2h[rsp_source][2] & 0x20) ? true :
6218                                                     false);
6219
6220                 coex_sta->is_A2DP_3M = ((coex_sta->bt_info_c2h[rsp_source][2] &
6221                                          0x10) ? true : false);
6222
6223                 coex_sta->acl_busy = ((coex_sta->bt_info_c2h[rsp_source][1] &
6224                                        0x9) ? true : false);
6225
6226                 coex_sta->voice_over_HOGP = ((coex_sta->bt_info_ext & 0x10) ?
6227                                              true : false);
6228
6229                 coex_sta->c2h_bt_inquiry_page = ((coex_sta->bt_info &
6230                           BT_INFO_8723D_2ANT_B_INQ_PAGE) ? true : false);
6231
6232                 coex_sta->a2dp_bit_pool = (((
6233                         coex_sta->bt_info_c2h[rsp_source][1] & 0x49) == 0x49) ?
6234                                    coex_sta->bt_info_c2h[rsp_source][6] : 0);
6235
6236                 coex_sta->bt_retry_cnt = coex_sta->bt_info_c2h[rsp_source][2] &
6237                                          0xf;
6238
6239                 coex_sta->is_autoslot = coex_sta->bt_info_ext2 & 0x8;
6240
6241                 coex_sta->forbidden_slot = coex_sta->bt_info_ext2 & 0x7;
6242
6243                 coex_sta->hid_busy_num = (coex_sta->bt_info_ext2 & 0x30) >> 4;
6244
6245                 coex_sta->hid_pair_cnt = (coex_sta->bt_info_ext2 & 0xc0) >> 6;
6246
6247                 if (coex_sta->bt_retry_cnt >= 1)
6248                         coex_sta->pop_event_cnt++;
6249
6250                 if (coex_sta->c2h_bt_remote_name_req)
6251                         coex_sta->cnt_RemoteNameReq++;
6252
6253                 if (coex_sta->bt_info_ext & BIT(1))
6254                         coex_sta->cnt_ReInit++;
6255
6256                 if (coex_sta->bt_info_ext & BIT(2)) {
6257                         coex_sta->cnt_setupLink++;
6258                         coex_sta->is_setupLink = true;
6259                 } else
6260                         coex_sta->is_setupLink = false;
6261
6262                 if (coex_sta->bt_info_ext & BIT(3))
6263                         coex_sta->cnt_IgnWlanAct++;
6264
6265                 if (coex_sta->bt_create_connection) {
6266                         coex_sta->cnt_Page++;
6267
6268                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
6269
6270                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
6271                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &wifi_link);
6272                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &wifi_roam);
6273
6274                         if ((wifi_link) || (wifi_roam) || (wifi_scan) ||
6275                                 (coex_sta->wifi_is_high_pri_task) || (wifi_busy)) {
6276
6277                                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6278                                          BT_8723D_2ANT_SCOREBOARD_SCAN, true);
6279
6280                       } else {
6281
6282                                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6283                                         BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6284                         }
6285                 } else
6286                                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6287                                         BT_8723D_2ANT_SCOREBOARD_SCAN, false);
6288
6289                 /* Here we need to resend some wifi info to BT */
6290                 /* because bt is reset and loss of the info. */
6291
6292                 if ((!btcoexist->manual_control) &&
6293                     (!btcoexist->stop_coex_dm)) {
6294
6295                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
6296                                            &wifi_connected);
6297
6298                         /*  Re-Init */
6299                         if ((coex_sta->bt_info_ext & BIT(1))) {
6300                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6301                                         "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
6302                                 BTC_TRACE(trace_buf);
6303                                 if (wifi_connected)
6304                                         halbtc8723d2ant_update_wifi_channel_info(
6305                                                 btcoexist, BTC_MEDIA_CONNECT);
6306                                 else
6307                                         halbtc8723d2ant_update_wifi_channel_info(
6308                                                 btcoexist,
6309                                                 BTC_MEDIA_DISCONNECT);
6310                         }
6311
6312
6313                         /*  If Ignore_WLanAct && not SetUp_Link or Role_Switch */
6314                         if ((coex_sta->bt_info_ext & BIT(3)) &&
6315                                 (!(coex_sta->bt_info_ext & BIT(2))) &&
6316                                 (!(coex_sta->bt_info_ext & BIT(6)))) {
6317
6318                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6319                                         "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
6320                                 BTC_TRACE(trace_buf);
6321                                 halbtc8723d2ant_ignore_wlan_act(btcoexist,
6322                                                         FORCE_EXEC, false);
6323                         } else {
6324                                 if (coex_sta->bt_info_ext & BIT(2)) {
6325                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6326                                         "[BTCoex], BT ignore Wlan active because Re-link!!\n");
6327                                         BTC_TRACE(trace_buf);
6328                                 } else if (coex_sta->bt_info_ext & BIT(6)) {
6329                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6330                                         "[BTCoex], BT ignore Wlan active because Role-Switch!!\n");
6331                                         BTC_TRACE(trace_buf);
6332                                 }
6333                         }
6334                 }
6335
6336         }
6337
6338         if ((coex_sta->bt_info_ext & BIT(5))) {
6339                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6340                                         "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
6341                 BTC_TRACE(trace_buf);
6342                 coex_sta->bt_ble_scan_type = btcoexist->btc_get_ble_scan_type_from_bt(btcoexist);
6343
6344                 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1)
6345                         coex_sta->bt_ble_scan_para[0]  = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x1);
6346                 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2)
6347                         coex_sta->bt_ble_scan_para[1]  = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x2);
6348                 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4)
6349                         coex_sta->bt_ble_scan_para[2]  = btcoexist->btc_get_ble_scan_para_from_bt(btcoexist, 0x4);
6350         }
6351
6352         halbtc8723d2ant_update_bt_link_info(btcoexist);
6353
6354         halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6355 }
6356
6357 void ex_halbtc8723d2ant_rf_status_notify(IN struct btc_coexist *btcoexist,
6358                 IN u8 type)
6359 {
6360         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
6361         BTC_TRACE(trace_buf);
6362
6363         if (BTC_RF_ON == type) {
6364                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6365                             "[BTCoex], RF is turned ON!!\n");
6366                 BTC_TRACE(trace_buf);
6367
6368                 btcoexist->stop_coex_dm = false;
6369
6370                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6371                                          BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6372                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6373                                          BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
6374         } else if (BTC_RF_OFF == type) {
6375                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6376                             "[BTCoex], RF is turned OFF!!\n");
6377                 BTC_TRACE(trace_buf);
6378
6379                 halbtc8723d2ant_set_ant_path(btcoexist,
6380                                              BTC_ANT_PATH_AUTO,
6381                                              FORCE_EXEC,
6382                                              BT_8723D_2ANT_PHASE_WLAN_OFF);
6383
6384                 halbtc8723d2ant_action_coex_all_off(btcoexist);
6385
6386                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6387                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
6388                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6389                                          BT_8723D_2ANT_SCOREBOARD_ONOFF, false);
6390                 btcoexist->stop_coex_dm = true;
6391
6392         }
6393 }
6394
6395 void ex_halbtc8723d2ant_halt_notify(IN struct btc_coexist *btcoexist)
6396 {
6397         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
6398         BTC_TRACE(trace_buf);
6399
6400         halbtc8723d2ant_set_ant_path(btcoexist,
6401                                      BTC_ANT_PATH_AUTO,
6402                                      FORCE_EXEC,
6403                                      BT_8723D_2ANT_PHASE_WLAN_OFF);
6404
6405         ex_halbtc8723d2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
6406
6407         halbtc8723d2ant_post_state_to_bt(btcoexist,
6408                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
6409         halbtc8723d2ant_post_state_to_bt(btcoexist,
6410                                          BT_8723D_2ANT_SCOREBOARD_ONOFF, false);
6411 }
6412
6413 void ex_halbtc8723d2ant_pnp_notify(IN struct btc_coexist *btcoexist,
6414                                    IN u8 pnp_state)
6415 {
6416         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
6417         BTC_TRACE(trace_buf);
6418
6419         if ((BTC_WIFI_PNP_SLEEP == pnp_state) ||
6420             (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state)) {
6421                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6422                             "[BTCoex], Pnp notify to SLEEP\n");
6423                 BTC_TRACE(trace_buf);
6424
6425                 /* Sinda 20150819, workaround for driver skip leave IPS/LPS to speed up sleep time. */
6426                 /* Driver do not leave IPS/LPS when driver is going to sleep, so BTCoexistence think wifi is still under IPS/LPS */
6427                 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch state after wakeup. */
6428                 coex_sta->under_ips = false;
6429                 coex_sta->under_lps = false;
6430
6431
6432                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6433                                  BT_8723D_2ANT_SCOREBOARD_ACTIVE, false);
6434                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6435                                          BT_8723D_2ANT_SCOREBOARD_ONOFF, false);
6436
6437                 if (BTC_WIFI_PNP_SLEEP_KEEP_ANT == pnp_state) {
6438
6439                         halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6440                                                      FORCE_EXEC,
6441                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
6442                 } else {
6443
6444                         halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6445                                                      FORCE_EXEC,
6446                                              BT_8723D_2ANT_PHASE_WLAN_OFF);
6447                 }
6448
6449
6450         } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
6451                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6452                             "[BTCoex], Pnp notify to WAKE UP\n");
6453                 BTC_TRACE(trace_buf);
6454
6455                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6456                                         BT_8723D_2ANT_SCOREBOARD_ACTIVE, true);
6457                 halbtc8723d2ant_post_state_to_bt(btcoexist,
6458                                         BT_8723D_2ANT_SCOREBOARD_ONOFF, true);
6459         }
6460 }
6461
6462 void ex_halbtc8723d2ant_periodical(IN struct btc_coexist *btcoexist)
6463 {
6464         struct  btc_board_info  *board_info = &btcoexist->board_info;
6465         boolean wifi_busy = false;
6466         u32     bt_patch_ver;
6467         static u8 cnt = 0;
6468         boolean bt_relink_finish = false;
6469
6470         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6471                     "[BTCoex], ************* Periodical *************\n");
6472         BTC_TRACE(trace_buf);
6473
6474 #if (BT_AUTO_REPORT_ONLY_8723D_2ANT == 0)
6475         halbtc8723d2ant_query_bt_info(btcoexist);
6476 #endif
6477
6478         halbtc8723d2ant_monitor_bt_ctr(btcoexist);
6479         halbtc8723d2ant_monitor_wifi_ctr(btcoexist);
6480         halbtc8723d2ant_monitor_bt_enable_disable(btcoexist);
6481
6482 # if 1
6483                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
6484
6485                 /* halbtc8723d2ant_read_score_board(btcoexist, &bt_scoreboard_val); */
6486
6487                 if (wifi_busy) {
6488                         halbtc8723d2ant_post_state_to_bt(btcoexist,
6489                                         BT_8723D_2ANT_SCOREBOARD_UNDERTEST, true);
6490                         /*
6491                         halbtc8723d2ant_post_state_to_bt(btcoexist,
6492                                                  BT_8723D_2ANT_SCOREBOARD_WLBUSY, true);
6493
6494                         if (bt_scoreboard_val & BIT(6))
6495                                 halbtc8723d2ant_query_bt_info(btcoexist); */
6496                 } else {
6497                         halbtc8723d2ant_post_state_to_bt(btcoexist,
6498                                                 BT_8723D_2ANT_SCOREBOARD_UNDERTEST, false);
6499                         /*
6500                         halbtc8723d2ant_post_state_to_bt(btcoexist,
6501                                                 BT_8723D_2ANT_SCOREBOARD_WLBUSY,
6502                                                 false);  */
6503                 }
6504 #endif
6505
6506         if (coex_sta->bt_relink_downcount != 0) {
6507                 coex_sta->bt_relink_downcount--;
6508
6509                 if (coex_sta->bt_relink_downcount == 0)
6510                         bt_relink_finish = true;
6511         }
6512
6513         /* for 4-way, DHCP, EAPOL packet */
6514         if (coex_sta->specific_pkt_period_cnt > 0) {
6515
6516                 coex_sta->specific_pkt_period_cnt--;
6517
6518                 if ((coex_sta->specific_pkt_period_cnt == 0) &&
6519                     (coex_sta->wifi_is_high_pri_task))
6520                         coex_sta->wifi_is_high_pri_task = false;
6521
6522                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6523                         "[BTCoex], ***************** Hi-Pri Task = %s*****************\n",
6524                             (coex_sta->wifi_is_high_pri_task ? "Yes" :
6525                              "No"));
6526                 BTC_TRACE(trace_buf);
6527
6528         }
6529
6530         if (!coex_sta->bt_disabled) {
6531                 if (coex_sta->bt_coex_supported_feature == 0)
6532                         btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_FEATURE,
6533                                                 &coex_sta->bt_coex_supported_feature);
6534
6535                 if ((coex_sta->bt_coex_supported_version == 0) ||
6536                          (coex_sta->bt_coex_supported_version == 0xffff))
6537                         btcoexist->btc_get(btcoexist, BTC_GET_U4_SUPPORTED_VERSION,
6538                                                 &coex_sta->bt_coex_supported_version);
6539
6540                 if (coex_sta->bt_reg_vendor_ac == 0xffff)
6541                         coex_sta->bt_reg_vendor_ac = (u16)(
6542                                                 btcoexist->btc_get_bt_reg(btcoexist, 3,
6543                                                 0xac) & 0xffff);
6544
6545                 if (coex_sta->bt_reg_vendor_ae == 0xffff)
6546                         coex_sta->bt_reg_vendor_ae = (u16)(
6547                                                 btcoexist->btc_get_bt_reg(btcoexist, 3,
6548                                                 0xae) & 0xffff);
6549
6550                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
6551                                                 &bt_patch_ver);
6552                 btcoexist->bt_info.bt_get_fw_ver = bt_patch_ver;
6553
6554                 if (coex_sta->num_of_profile > 0) {
6555                         cnt++;
6556
6557                         if (cnt >= 3) {
6558                                 btcoexist->btc_get_bt_afh_map_from_bt(btcoexist, 0,
6559                                         &coex_sta->bt_afh_map[0]);
6560                                 cnt = 0;
6561                         }
6562                 }
6563
6564 #if BT_8723D_2ANT_ANTDET_ENABLE
6565
6566                 if (board_info->btdm_ant_det_finish) {
6567                         if ((psd_scan->ant_det_result == 12) &&
6568                             (psd_scan->ant_det_psd_scan_peak_val == 0)
6569                             && (!psd_scan->is_AntDet_running))
6570                                 psd_scan->ant_det_psd_scan_peak_val =
6571                                         btcoexist->btc_get_ant_det_val_from_bt(
6572                                                 btcoexist) * 100;
6573                 }
6574
6575 #endif
6576         }
6577
6578
6579         if (halbtc8723d2ant_is_wifibt_status_changed(btcoexist))
6580                 halbtc8723d2ant_run_coexist_mechanism(btcoexist);
6581 }
6582
6583 void ex_halbtc8723d2ant_set_antenna_notify(IN struct btc_coexist *btcoexist,
6584                 IN u8 type)
6585 {
6586         struct  btc_board_info  *board_info = &btcoexist->board_info;
6587
6588         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
6589                 return;
6590
6591         if (type == 2) { /* two antenna */
6592                 board_info->ant_div_cfg = true;
6593
6594                 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
6595                                              FORCE_EXEC,
6596                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
6597
6598         } else { /* one antenna */
6599
6600                 halbtc8723d2ant_set_ant_path(btcoexist, BTC_ANT_PATH_AUTO,
6601                                              FORCE_EXEC,
6602                                              BT_8723D_2ANT_PHASE_2G_RUNTIME);
6603
6604         }
6605 }
6606
6607 #ifdef PLATFORM_WINDOWS
6608 #pragma optimize("", off)
6609 #endif
6610 void ex_halbtc8723d2ant_antenna_detection(IN struct btc_coexist *btcoexist,
6611                 IN u32 cent_freq, IN u32 offset, IN u32 span, IN u32 seconds)
6612 {
6613
6614         static u32 ant_det_count = 0, ant_det_fail_count = 0;
6615         struct  btc_board_info  *board_info = &btcoexist->board_info;
6616         u16             u16tmp;
6617         u8                      AntDetval = 0;
6618
6619         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6620                     "xxxxxxxxxxxxxxxx Ext Call AntennaDetect()!!\n");
6621         BTC_TRACE(trace_buf);
6622
6623 #if BT_8723D_2ANT_ANTDET_ENABLE
6624
6625         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6626                     "xxxxxxxxxxxxxxxx Call AntennaDetect()!!\n");
6627         BTC_TRACE(trace_buf);
6628
6629         if (seconds == 0) {
6630                 psd_scan->ant_det_try_count     = 0;
6631                 psd_scan->ant_det_fail_count    = 0;
6632                 ant_det_count = 0;
6633                 ant_det_fail_count = 0;
6634                 board_info->btdm_ant_det_finish = false;
6635                 board_info->btdm_ant_num_by_ant_det = 1;
6636                 return;
6637         }
6638
6639         if (!board_info->btdm_ant_det_finish) {
6640                 psd_scan->ant_det_inteval_count =
6641                         psd_scan->ant_det_inteval_count + 2;
6642
6643                 if (psd_scan->ant_det_inteval_count >=
6644                     BT_8723D_2ANT_ANTDET_RETRY_INTERVAL) {
6645                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6646                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is up, Try Detect!!\n");
6647                         BTC_TRACE(trace_buf);
6648
6649                         psd_scan->is_AntDet_running = true;
6650
6651                         halbtc8723d2ant_read_score_board(btcoexist,     &u16tmp);
6652
6653                         if (u16tmp & BIT(
6654                                 2)) { /* Antenna detection is already done before last WL power on   */
6655                                 board_info->btdm_ant_det_finish = true;
6656                                 psd_scan->ant_det_try_count = 1;
6657                                 psd_scan->ant_det_fail_count = 0;
6658                                 board_info->btdm_ant_num_by_ant_det = (u16tmp &
6659                                                                BIT(3)) ? 1 : 2;
6660                                 psd_scan->ant_det_result = 12;
6661
6662                                 psd_scan->ant_det_psd_scan_peak_val =
6663                                         btcoexist->btc_get_ant_det_val_from_bt(
6664                                                 btcoexist) * 100;
6665
6666                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6667                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Result from BT (%d-Ant)\n",
6668                                         board_info->btdm_ant_num_by_ant_det);
6669                                 BTC_TRACE(trace_buf);
6670                         } else
6671                                 board_info->btdm_ant_det_finish =
6672                                         halbtc8723d2ant_psd_antenna_detection_check(
6673                                                 btcoexist);
6674
6675                         btcoexist->bdontenterLPS = false;
6676
6677                         if (board_info->btdm_ant_det_finish) {
6678                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6679                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Success!!\n");
6680                                 BTC_TRACE(trace_buf);
6681
6682                                 /*for 8723d, btc_set_bt_trx_mask is just used to
6683                                         notify BT stop le tx and Ant Det Result , not set BT RF TRx Mask  */
6684                                 if (psd_scan->ant_det_result != 12) {
6685
6686                                         AntDetval = (u8)(
6687                                                 psd_scan->ant_det_psd_scan_peak_val
6688                                                             / 100) & 0x7f;
6689
6690                                         AntDetval =
6691                                                 (board_info->btdm_ant_num_by_ant_det
6692                                                  == 1) ? (AntDetval | 0x80) :
6693                                                 AntDetval;
6694
6695                                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6696                                                 "xxxxxx AntennaDetect(), Ant Count = %d, PSD Val = %d\n",
6697                                                     ((AntDetval &
6698                                                       0x80) ? 1
6699                                                      : 2), AntDetval
6700                                                     & 0x7f);
6701                                         BTC_TRACE(trace_buf);
6702
6703                                         if (btcoexist->btc_set_bt_trx_mask(
6704                                                     btcoexist, AntDetval))
6705                                                 BTC_SPRINTF(trace_buf,
6706                                                             BT_TMP_BUF_SIZE,
6707                                                         "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask ok!\n");
6708                                         else
6709                                                 BTC_SPRINTF(trace_buf,
6710                                                             BT_TMP_BUF_SIZE,
6711                                                         "xxxxxx AntennaDetect(), Notify BT stop le tx by set_bt_trx_mask fail!\n");
6712
6713                                         BTC_TRACE(trace_buf);
6714                                 } else
6715                                         board_info->antdetval =
6716                                                 psd_scan->ant_det_psd_scan_peak_val/100;
6717
6718                                 board_info->btdm_ant_det_complete_fail = false;
6719
6720                         } else {
6721                                 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6722                                         "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Fail!!\n");
6723                                 BTC_TRACE(trace_buf);
6724                         }
6725
6726                         psd_scan->ant_det_inteval_count = 0;
6727                         psd_scan->is_AntDet_running = false;
6728
6729                         /* stimulate coex running */
6730                         halbtc8723d2ant_run_coexist_mechanism(
6731                                 btcoexist);
6732                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6733                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Stimulate Coex running\n!!");
6734                         BTC_TRACE(trace_buf);
6735                 } else {
6736                         BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
6737                                 "xxxxxxxxxxxxxxxx AntennaDetect(), Antenna Det Timer is not up! (%d)\n",
6738                                     psd_scan->ant_det_inteval_count);
6739                         BTC_TRACE(trace_buf);
6740
6741                         if (psd_scan->ant_det_inteval_count == 8)
6742                                 btcoexist->bdontenterLPS = true;
6743                         else
6744                                 btcoexist->bdontenterLPS = false;
6745                 }
6746
6747         }
6748 #endif
6749
6750
6751 }
6752
6753
6754 void ex_halbtc8723d2ant_display_ant_detection(IN struct btc_coexist *btcoexist)
6755 {
6756
6757 #if BT_8723D_2ANT_ANTDET_ENABLE
6758         struct  btc_board_info  *board_info = &btcoexist->board_info;
6759
6760         if (psd_scan->ant_det_try_count != 0)   {
6761                 halbtc8723d2ant_psd_show_antenna_detect_result(btcoexist);
6762
6763                 if (board_info->btdm_ant_det_finish)
6764                         halbtc8723d2ant_psd_showdata(btcoexist);
6765         }
6766 #endif
6767
6768 }
6769
6770
6771 #endif
6772
6773 #endif  /*  #if (RTL8723D_SUPPORT == 1) */
6774