rtl8723bu/hal/btc/HalBtc8723b1Ant.c

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