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