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

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