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

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