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