drivers/staging/rtlwifi/btcoexist/halbtc8822b1ant.c

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