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