drivers/staging/rtlwifi/btcoexist/halbtc8822b1ant.c

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