drivers/net/wireless/realtek/rtlwifi/btcoexist/halbtc8821a1ant.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2012  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 /**************************************************************
  27  * Description:
  28  *
  29  * This file is for RTL8821A Co-exist mechanism
  30  *
  31  * History
  32  * 2012/11/15 Cosa first check in.
  33  *
  34  **************************************************************/
  35
  36 /**************************************************************
  37  * include files
  38  **************************************************************/
  39 #include "halbt_precomp.h"
  40 /**************************************************************
  41  * Global variables, these are static variables
  42  **************************************************************/
  43 static struct coex_dm_8821a_1ant glcoex_dm_8821a_1ant;
  44 static struct coex_dm_8821a_1ant *coex_dm = &glcoex_dm_8821a_1ant;
  45 static struct coex_sta_8821a_1ant glcoex_sta_8821a_1ant;
  46 static struct coex_sta_8821a_1ant *coex_sta = &glcoex_sta_8821a_1ant;
  47 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
  48                                                   u8 wifi_status);
  49
  50 static const char *const glbt_info_src_8821a_1ant[] = {
  51           "BT Info[wifi fw]",
  52           "BT Info[bt rsp]",
  53           "BT Info[bt auto report]",
  54 };
  55
  56 static u32 glcoex_ver_date_8821a_1ant = 20130816;
  57 static u32 glcoex_ver_8821a_1ant = 0x41;
  58
  59 /**************************************************************
  60  * local function proto type if needed
  61  *
  62  * local function start with btc8821a1ant_
  63  **************************************************************/
  64 static u8 btc8821a1ant_bt_rssi_state(struct btc_coexist *btcoexist,
  65                                      u8 level_num, u8 rssi_thresh,
  66                                      u8 rssi_thresh1)
  67 {
  68         struct rtl_priv *rtlpriv = btcoexist->adapter;
  69         long bt_rssi = 0;
  70         u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
  71
  72         bt_rssi = coex_sta->bt_rssi;
  73
  74         if (level_num == 2) {
  75                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  76                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  77                         if (bt_rssi >= (rssi_thresh +
  78                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
  79                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  80                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  81                                          "[BTCoex], BT Rssi state switch to High\n");
  82                         } else {
  83                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  84                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  85                                          "[BTCoex], BT Rssi state stay at Low\n");
  86                         }
  87                 } else {
  88                         if (bt_rssi < rssi_thresh) {
  89                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
  90                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  91                                          "[BTCoex], BT Rssi state switch to Low\n");
  92                         } else {
  93                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  94                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
  95                                          "[BTCoex], BT Rssi state stay at High\n");
  96                         }
  97                 }
  98         } else if (level_num == 3) {
  99                 if (rssi_thresh > rssi_thresh1) {
 100                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 101                                  "[BTCoex], BT Rssi thresh error!!\n");
 102                         return coex_sta->pre_bt_rssi_state;
 103                 }
 104
 105                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
 106                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 107                         if (bt_rssi >= (rssi_thresh +
 108                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
 109                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 110                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 111                                          "[BTCoex], BT Rssi state switch to Medium\n");
 112                         } else {
 113                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 114                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 115                                          "[BTCoex], BT Rssi state stay at Low\n");
 116                         }
 117                 } else if ((coex_sta->pre_bt_rssi_state ==
 118                            BTC_RSSI_STATE_MEDIUM) ||
 119                            (coex_sta->pre_bt_rssi_state ==
 120                             BTC_RSSI_STATE_STAY_MEDIUM)) {
 121                         if (bt_rssi >= (rssi_thresh1 +
 122                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
 123                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
 124                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 125                                          "[BTCoex], BT Rssi state switch to High\n");
 126                         } else if (bt_rssi < rssi_thresh) {
 127                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
 128                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 129                                          "[BTCoex], BT Rssi state switch to Low\n");
 130                         } else {
 131                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 132                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 133                                          "[BTCoex], BT Rssi state stay at Medium\n");
 134                         }
 135                 } else {
 136                         if (bt_rssi < rssi_thresh1) {
 137                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 138                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 139                                          "[BTCoex], BT Rssi state switch to Medium\n");
 140                         } else {
 141                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 142                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 143                                          "[BTCoex], BT Rssi state stay at High\n");
 144                         }
 145                 }
 146         }
 147         coex_sta->pre_bt_rssi_state = bt_rssi_state;
 148
 149         return bt_rssi_state;
 150 }
 151
 152 static u8 btc8821a1ant_wifi_rssi_state(struct btc_coexist *btcoexist,
 153                                        u8 index, u8 level_num, u8 rssi_thresh,
 154                                        u8 rssi_thresh1)
 155 {
 156         struct rtl_priv *rtlpriv = btcoexist->adapter;
 157         long    wifi_rssi = 0;
 158         u8      wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
 159
 160         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 161
 162         if (level_num == 2) {
 163                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 164                      BTC_RSSI_STATE_LOW) ||
 165                     (coex_sta->pre_wifi_rssi_state[index] ==
 166                      BTC_RSSI_STATE_STAY_LOW)) {
 167                         if (wifi_rssi >= (rssi_thresh +
 168                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
 169                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 170                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 171                                          "[BTCoex], wifi RSSI state switch to High\n");
 172                         } else {
 173                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 174                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 175                                          "[BTCoex], wifi RSSI state stay at Low\n");
 176                         }
 177                 } else {
 178                         if (wifi_rssi < rssi_thresh) {
 179                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 180                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 181                                          "[BTCoex], wifi RSSI state switch to Low\n");
 182                         } else {
 183                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 184                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 185                                          "[BTCoex], wifi RSSI state stay at High\n");
 186                         }
 187                 }
 188         } else if (level_num == 3) {
 189                 if (rssi_thresh > rssi_thresh1) {
 190                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 191                                  "[BTCoex], wifi RSSI thresh error!!\n");
 192                         return coex_sta->pre_wifi_rssi_state[index];
 193                 }
 194
 195                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 196                      BTC_RSSI_STATE_LOW) ||
 197                     (coex_sta->pre_wifi_rssi_state[index] ==
 198                      BTC_RSSI_STATE_STAY_LOW)) {
 199                         if (wifi_rssi >= (rssi_thresh +
 200                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
 201                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 202                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 203                                          "[BTCoex], wifi RSSI state switch to Medium\n");
 204                         } else {
 205                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 206                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 207                                          "[BTCoex], wifi RSSI state stay at Low\n");
 208                         }
 209                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
 210                         BTC_RSSI_STATE_MEDIUM) ||
 211                         (coex_sta->pre_wifi_rssi_state[index] ==
 212                         BTC_RSSI_STATE_STAY_MEDIUM)) {
 213                         if (wifi_rssi >= (rssi_thresh1 +
 214                                         BTC_RSSI_COEX_THRESH_TOL_8821A_1ANT)) {
 215                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 216                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 217                                          "[BTCoex], wifi RSSI state switch to High\n");
 218                         } else if (wifi_rssi < rssi_thresh) {
 219                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 220                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 221                                          "[BTCoex], wifi RSSI state switch to Low\n");
 222                         } else {
 223                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 224                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 225                                          "[BTCoex], wifi RSSI state stay at Medium\n");
 226                         }
 227                 } else {
 228                         if (wifi_rssi < rssi_thresh1) {
 229                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 230                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 231                                          "[BTCoex], wifi RSSI state switch to Medium\n");
 232                         } else {
 233                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 234                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 235                                          "[BTCoex], wifi RSSI state stay at High\n");
 236                         }
 237                 }
 238         }
 239         coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
 240
 241         return wifi_rssi_state;
 242 }
 243
 244 static void btc8821a1ant_update_ra_mask(struct btc_coexist *btcoexist,
 245                                         bool force_exec, u32 dis_rate_mask)
 246 {
 247         coex_dm->cur_ra_mask = dis_rate_mask;
 248
 249         if (force_exec ||
 250             (coex_dm->pre_ra_mask != coex_dm->cur_ra_mask)) {
 251                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_UPDATE_RAMASK,
 252                                    &coex_dm->cur_ra_mask);
 253         }
 254         coex_dm->pre_ra_mask = coex_dm->cur_ra_mask;
 255 }
 256
 257 static void btc8821a1ant_auto_rate_fb_retry(struct btc_coexist *btcoexist,
 258                                             bool force_exec, u8 type)
 259 {
 260         bool wifi_under_b_mode = false;
 261
 262         coex_dm->cur_arfr_type = type;
 263
 264         if (force_exec ||
 265             (coex_dm->pre_arfr_type != coex_dm->cur_arfr_type)) {
 266                 switch (coex_dm->cur_arfr_type) {
 267                 case 0: /* normal mode */
 268                         btcoexist->btc_write_4byte(btcoexist, 0x430,
 269                                                    coex_dm->backup_arfr_cnt1);
 270                         btcoexist->btc_write_4byte(btcoexist, 0x434,
 271                                                    coex_dm->backup_arfr_cnt2);
 272                         break;
 273                 case 1:
 274                         btcoexist->btc_get(btcoexist,
 275                                            BTC_GET_BL_WIFI_UNDER_B_MODE,
 276                                            &wifi_under_b_mode);
 277                         if (wifi_under_b_mode) {
 278                                 btcoexist->btc_write_4byte(btcoexist, 0x430,
 279                                                            0x0);
 280                                 btcoexist->btc_write_4byte(btcoexist, 0x434,
 281                                                            0x01010101);
 282                         } else {
 283                                 btcoexist->btc_write_4byte(btcoexist, 0x430,
 284                                                            0x0);
 285                                 btcoexist->btc_write_4byte(btcoexist, 0x434,
 286                                                            0x04030201);
 287                         }
 288                         break;
 289                 default:
 290                         break;
 291                 }
 292         }
 293
 294         coex_dm->pre_arfr_type = coex_dm->cur_arfr_type;
 295 }
 296
 297 static void btc8821a1ant_retry_limit(struct btc_coexist *btcoexist,
 298                                      bool force_exec, u8 type)
 299 {
 300         coex_dm->cur_retry_limit_type = type;
 301
 302         if (force_exec ||
 303             (coex_dm->pre_retry_limit_type != coex_dm->cur_retry_limit_type)) {
 304                 switch (coex_dm->cur_retry_limit_type) {
 305                 case 0: /* normal mode */
 306                         btcoexist->btc_write_2byte(btcoexist, 0x42a,
 307                                                    coex_dm->backup_retry_limit);
 308                         break;
 309                 case 1: /* retry limit = 8 */
 310                         btcoexist->btc_write_2byte(btcoexist, 0x42a, 0x0808);
 311                         break;
 312                 default:
 313                         break;
 314                 }
 315         }
 316         coex_dm->pre_retry_limit_type = coex_dm->cur_retry_limit_type;
 317 }
 318
 319 static void btc8821a1ant_ampdu_max_time(struct btc_coexist *btcoexist,
 320                                         bool force_exec, u8 type)
 321 {
 322         coex_dm->cur_ampdu_time_type = type;
 323
 324         if (force_exec ||
 325             (coex_dm->pre_ampdu_time_type != coex_dm->cur_ampdu_time_type)) {
 326                 switch (coex_dm->cur_ampdu_time_type) {
 327                 case 0: /* normal mode */
 328                         btcoexist->btc_write_1byte(btcoexist, 0x456,
 329                                                    coex_dm->backup_ampdu_max_time);
 330                         break;
 331                 case 1: /* AMPDU time = 0x38 * 32us */
 332                         btcoexist->btc_write_1byte(btcoexist, 0x456, 0x38);
 333                         break;
 334                 default:
 335                         break;
 336                 }
 337         }
 338
 339         coex_dm->pre_ampdu_time_type = coex_dm->cur_ampdu_time_type;
 340 }
 341
 342 static void btc8821a1ant_limited_tx(struct btc_coexist *btcoexist,
 343                                     bool force_exec, u8 ra_mask_type,
 344                                     u8 arfr_type, u8 retry_limit_type,
 345                                     u8 ampdu_time_type)
 346 {
 347         switch (ra_mask_type) {
 348         case 0: /* normal mode */
 349                 btc8821a1ant_update_ra_mask(btcoexist, force_exec, 0x0);
 350                 break;
 351         case 1: /* disable cck 1/2 */
 352                 btc8821a1ant_update_ra_mask(btcoexist, force_exec,
 353                                             0x00000003);
 354                 break;
 355         case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
 356                 btc8821a1ant_update_ra_mask(btcoexist, force_exec,
 357                                             0x0001f1f7);
 358                 break;
 359         default:
 360                 break;
 361         }
 362
 363         btc8821a1ant_auto_rate_fb_retry(btcoexist, force_exec, arfr_type);
 364         btc8821a1ant_retry_limit(btcoexist, force_exec, retry_limit_type);
 365         btc8821a1ant_ampdu_max_time(btcoexist, force_exec, ampdu_time_type);
 366 }
 367
 368 static void btc8821a1ant_limited_rx(struct btc_coexist *btcoexist,
 369                                     bool force_exec, bool rej_ap_agg_pkt,
 370                                     bool bt_ctrl_agg_buf_size, u8 agg_buf_size)
 371 {
 372         bool reject_rx_agg = rej_ap_agg_pkt;
 373         bool bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
 374         u8 rx_agg_size = agg_buf_size;
 375
 376         /* Rx Aggregation related setting */
 377         btcoexist->btc_set(btcoexist,
 378                  BTC_SET_BL_TO_REJ_AP_AGG_PKT, &reject_rx_agg);
 379         /* decide BT control aggregation buf size or not */
 380         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE,
 381                            &bt_ctrl_rx_agg_size);
 382         /* aggregation buf size, only work when BT control Rx agg size */
 383         btcoexist->btc_set(btcoexist, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
 384         /* real update aggregation setting */
 385         btcoexist->btc_set(btcoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 386 }
 387
 388 static void btc8821a1ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 389 {
 390         u32 reg_hp_tx_rx, reg_lp_tx_rx, u4_tmp;
 391         u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
 392
 393         reg_hp_tx_rx = 0x770;
 394         reg_lp_tx_rx = 0x774;
 395
 396         u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_tx_rx);
 397         reg_hp_tx = u4_tmp & MASKLWORD;
 398         reg_hp_rx = (u4_tmp & MASKHWORD) >> 16;
 399
 400         u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_tx_rx);
 401         reg_lp_tx = u4_tmp & MASKLWORD;
 402         reg_lp_rx = (u4_tmp & MASKHWORD) >> 16;
 403
 404         coex_sta->high_priority_tx = reg_hp_tx;
 405         coex_sta->high_priority_rx = reg_hp_rx;
 406         coex_sta->low_priority_tx = reg_lp_tx;
 407         coex_sta->low_priority_rx = reg_lp_rx;
 408
 409         /* reset counter */
 410         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 411 }
 412
 413 static void btc8821a1ant_query_bt_info(struct btc_coexist *btcoexist)
 414 {
 415         struct rtl_priv *rtlpriv = btcoexist->adapter;
 416         u8 h2c_parameter[1] = {0};
 417
 418         coex_sta->c2h_bt_info_req_sent = true;
 419
 420         h2c_parameter[0] |= BIT0; /* trigger */
 421
 422         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 423                  "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
 424                  h2c_parameter[0]);
 425
 426         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 427 }
 428
 429 bool btc8821a1ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
 430 {
 431         static bool pre_wifi_busy = true;
 432         static bool pre_under_4way = true;
 433         static bool pre_bt_hs_on = true;
 434         bool wifi_busy = false, under_4way = false, bt_hs_on = false;
 435         bool wifi_connected = false;
 436
 437         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 438                            &wifi_connected);
 439         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 440         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 441         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 442                            &under_4way);
 443
 444         if (wifi_connected) {
 445                 if (wifi_busy != pre_wifi_busy) {
 446                         pre_wifi_busy = wifi_busy;
 447                         return true;
 448                 }
 449                 if (under_4way != pre_under_4way) {
 450                         pre_under_4way = under_4way;
 451                         return true;
 452                 }
 453                 if (bt_hs_on != pre_bt_hs_on) {
 454                         pre_bt_hs_on = bt_hs_on;
 455                         return true;
 456                 }
 457         }
 458
 459         return false;
 460 }
 461
 462 static void btc8821a1ant_update_bt_link_info(struct btc_coexist *btcoexist)
 463 {
 464         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 465         bool bt_hs_on = false;
 466
 467         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 468
 469         bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 470         bt_link_info->sco_exist = coex_sta->sco_exist;
 471         bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 472         bt_link_info->pan_exist = coex_sta->pan_exist;
 473         bt_link_info->hid_exist = coex_sta->hid_exist;
 474
 475         /* work around for HS mode */
 476         if (bt_hs_on) {
 477                 bt_link_info->pan_exist = true;
 478                 bt_link_info->bt_link_exist = true;
 479         }
 480
 481         /* check if Sco only */
 482         if (bt_link_info->sco_exist &&
 483             !bt_link_info->a2dp_exist &&
 484             !bt_link_info->pan_exist &&
 485             !bt_link_info->hid_exist)
 486                 bt_link_info->sco_only = true;
 487         else
 488                 bt_link_info->sco_only = false;
 489
 490         /* check if A2dp only */
 491         if (!bt_link_info->sco_exist &&
 492             bt_link_info->a2dp_exist &&
 493             !bt_link_info->pan_exist &&
 494             !bt_link_info->hid_exist)
 495                 bt_link_info->a2dp_only = true;
 496         else
 497                 bt_link_info->a2dp_only = false;
 498
 499         /* check if Pan only */
 500         if (!bt_link_info->sco_exist &&
 501             !bt_link_info->a2dp_exist &&
 502             bt_link_info->pan_exist &&
 503             !bt_link_info->hid_exist)
 504                 bt_link_info->pan_only = true;
 505         else
 506                 bt_link_info->pan_only = false;
 507
 508         /* check if Hid only */
 509         if (!bt_link_info->sco_exist &&
 510             !bt_link_info->a2dp_exist &&
 511             !bt_link_info->pan_exist &&
 512             bt_link_info->hid_exist)
 513                 bt_link_info->hid_only = true;
 514         else
 515                 bt_link_info->hid_only = false;
 516 }
 517
 518 static u8 btc8821a1ant_action_algorithm(struct btc_coexist *btcoexist)
 519 {
 520         struct rtl_priv *rtlpriv = btcoexist->adapter;
 521         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 522         bool bt_hs_on = false;
 523         u8 algorithm = BT_8821A_1ANT_COEX_ALGO_UNDEFINED;
 524         u8 num_of_diff_profile = 0;
 525
 526         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 527
 528         if (!bt_link_info->bt_link_exist) {
 529                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 530                          "[BTCoex], No BT link exists!!!\n");
 531                 return algorithm;
 532         }
 533
 534         if (bt_link_info->sco_exist)
 535                 num_of_diff_profile++;
 536         if (bt_link_info->hid_exist)
 537                 num_of_diff_profile++;
 538         if (bt_link_info->pan_exist)
 539                 num_of_diff_profile++;
 540         if (bt_link_info->a2dp_exist)
 541                 num_of_diff_profile++;
 542
 543         if (num_of_diff_profile == 1) {
 544                 if (bt_link_info->sco_exist) {
 545                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 546                                  "[BTCoex], BT Profile = SCO only\n");
 547                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
 548                 } else {
 549                         if (bt_link_info->hid_exist) {
 550                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 551                                          "[BTCoex], BT Profile = HID only\n");
 552                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
 553                         } else if (bt_link_info->a2dp_exist) {
 554                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 555                                          "[BTCoex], BT Profile = A2DP only\n");
 556                                 algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP;
 557                         } else if (bt_link_info->pan_exist) {
 558                                 if (bt_hs_on) {
 559                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 560                                                  DBG_LOUD,
 561                                                  "[BTCoex], BT Profile = PAN(HS) only\n");
 562                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANHS;
 563                                 } else {
 564                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 565                                                  DBG_LOUD,
 566                                                  "[BTCoex], BT Profile = PAN(EDR) only\n");
 567                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR;
 568                                 }
 569                         }
 570                 }
 571         } else if (num_of_diff_profile == 2) {
 572                 if (bt_link_info->sco_exist) {
 573                         if (bt_link_info->hid_exist) {
 574                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 575                                          "[BTCoex], BT Profile = SCO + HID\n");
 576                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
 577                         } else if (bt_link_info->a2dp_exist) {
 578                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 579                                          "[BTCoex], BT Profile = SCO + A2DP ==> SCO\n");
 580                                 algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
 581                         } else if (bt_link_info->pan_exist) {
 582                                 if (bt_hs_on) {
 583                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 584                                                  DBG_LOUD,
 585                                                  "[BTCoex], BT Profile = SCO + PAN(HS)\n");
 586                                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
 587                                 } else {
 588                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 589                                                  DBG_LOUD,
 590                                                  "[BTCoex], BT Profile = SCO + PAN(EDR)\n");
 591                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
 592                                 }
 593                         }
 594                 } else {
 595                         if (bt_link_info->hid_exist &&
 596                             bt_link_info->a2dp_exist) {
 597                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 598                                          "[BTCoex], BT Profile = HID + A2DP\n");
 599                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
 600                         } else if (bt_link_info->hid_exist &&
 601                                    bt_link_info->pan_exist) {
 602                                 if (bt_hs_on) {
 603                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 604                                                  DBG_LOUD,
 605                                                  "[BTCoex], BT Profile = HID + PAN(HS)\n");
 606                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
 607                                 } else {
 608                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 609                                                  DBG_LOUD,
 610                                                  "[BTCoex], BT Profile = HID + PAN(EDR)\n");
 611                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
 612                                 }
 613                         } else if (bt_link_info->pan_exist &&
 614                                    bt_link_info->a2dp_exist) {
 615                                 if (bt_hs_on) {
 616                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 617                                                  DBG_LOUD,
 618                                                  "[BTCoex], BT Profile = A2DP + PAN(HS)\n");
 619                                         algorithm = BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS;
 620                                 } else {
 621                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 622                                                  DBG_LOUD,
 623                                                  "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
 624                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP;
 625                                 }
 626                         }
 627                 }
 628         } else if (num_of_diff_profile == 3) {
 629                 if (bt_link_info->sco_exist) {
 630                         if (bt_link_info->hid_exist &&
 631                             bt_link_info->a2dp_exist) {
 632                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 633                                          "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID\n");
 634                                 algorithm = BT_8821A_1ANT_COEX_ALGO_HID;
 635                         } else if (bt_link_info->hid_exist &&
 636                                    bt_link_info->pan_exist) {
 637                                 if (bt_hs_on) {
 638                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 639                                                  DBG_LOUD,
 640                                                  "[BTCoex], BT Profile = SCO + HID + PAN(HS)\n");
 641                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
 642                                 } else {
 643                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 644                                                  DBG_LOUD,
 645                                                  "[BTCoex], BT Profile = SCO + HID + PAN(EDR)\n");
 646                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
 647                                 }
 648                         } else if (bt_link_info->pan_exist &&
 649                                    bt_link_info->a2dp_exist) {
 650                                 if (bt_hs_on) {
 651                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 652                                                  DBG_LOUD,
 653                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(HS)\n");
 654                                         algorithm = BT_8821A_1ANT_COEX_ALGO_SCO;
 655                                 } else {
 656                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 657                                                  DBG_LOUD,
 658                                                  "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> HID\n");
 659                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
 660                                 }
 661                         }
 662                 } else {
 663                         if (bt_link_info->hid_exist &&
 664                             bt_link_info->pan_exist &&
 665                             bt_link_info->a2dp_exist) {
 666                                 if (bt_hs_on) {
 667                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 668                                                  DBG_LOUD,
 669                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(HS)\n");
 670                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP;
 671                                 } else {
 672                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 673                                                  DBG_LOUD,
 674                                                  "[BTCoex], BT Profile = HID + A2DP + PAN(EDR)\n");
 675                                         algorithm = BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
 676                                 }
 677                         }
 678                 }
 679         } else if (num_of_diff_profile >= 3) {
 680                 if (bt_link_info->sco_exist) {
 681                         if (bt_link_info->hid_exist &&
 682                             bt_link_info->pan_exist &&
 683                             bt_link_info->a2dp_exist) {
 684                                 if (bt_hs_on) {
 685                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 686                                                  DBG_LOUD,
 687                                                  "[BTCoex], Error!!! BT Profile = SCO + HID + A2DP + PAN(HS)\n");
 688
 689                                 } else {
 690                                         RT_TRACE(rtlpriv, COMP_BT_COEXIST,
 691                                                  DBG_LOUD,
 692                                                  "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
 693                                         algorithm = BT_8821A_1ANT_COEX_ALGO_PANEDR_HID;
 694                                 }
 695                         }
 696                 }
 697         }
 698         return algorithm;
 699 }
 700
 701 static void btc8821a1ant_set_sw_penalty_tx_rate(struct btc_coexist *btcoexist,
 702                                                 bool low_penalty_ra)
 703 {
 704         struct rtl_priv *rtlpriv = btcoexist->adapter;
 705         u8 h2c_parameter[6] = {0};
 706
 707         h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/
 708
 709         if (low_penalty_ra) {
 710                 h2c_parameter[1] |= BIT0;
 711                 /* normal rate except MCS7/6/5, OFDM54/48/36 */
 712                 h2c_parameter[2] = 0x00;
 713                 h2c_parameter[3] = 0xf7; /* MCS7 or OFDM54 */
 714                 h2c_parameter[4] = 0xf8; /* MCS6 or OFDM48 */
 715                 h2c_parameter[5] = 0xf9; /* MCS5 or OFDM36 */
 716         }
 717
 718         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 719                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
 720                  (low_penalty_ra ? "ON!!" : "OFF!!"));
 721
 722         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 723 }
 724
 725 static void btc8821a1ant_low_penalty_ra(struct btc_coexist *btcoexist,
 726                                         bool force_exec, bool low_penalty_ra)
 727 {
 728         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 729
 730         if (!force_exec) {
 731                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 732                         return;
 733         }
 734         btc8821a1ant_set_sw_penalty_tx_rate(btcoexist,
 735                                             coex_dm->cur_low_penalty_ra);
 736
 737         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 738 }
 739
 740 static void btc8821a1ant_set_coex_table(struct btc_coexist *btcoexist,
 741                                         u32 val0x6c0, u32 val0x6c4,
 742                                         u32 val0x6c8, u8 val0x6cc)
 743 {
 744         struct rtl_priv *rtlpriv = btcoexist->adapter;
 745
 746         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 747                  "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
 748         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 749
 750         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 751                  "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
 752         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 753
 754         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 755                  "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
 756         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 757
 758         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 759                  "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
 760         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 761 }
 762
 763 static void btc8821a1ant_coex_table(struct btc_coexist *btcoexist,
 764                                     bool force_exec, u32 val0x6c0, u32 val0x6c4,
 765                                     u32 val0x6c8, u8 val0x6cc)
 766 {
 767         struct rtl_priv *rtlpriv = btcoexist->adapter;
 768
 769         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 770                  "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
 771                     (force_exec ? "force to" : ""), val0x6c0, val0x6c4,
 772                     val0x6c8, val0x6cc);
 773         coex_dm->cur_val_0x6c0 = val0x6c0;
 774         coex_dm->cur_val_0x6c4 = val0x6c4;
 775         coex_dm->cur_val_0x6c8 = val0x6c8;
 776         coex_dm->cur_val_0x6cc = val0x6cc;
 777
 778         if (!force_exec) {
 779                 if ((coex_dm->pre_val_0x6c0 == coex_dm->cur_val_0x6c0) &&
 780                     (coex_dm->pre_val_0x6c4 == coex_dm->cur_val_0x6c4) &&
 781                     (coex_dm->pre_val_0x6c8 == coex_dm->cur_val_0x6c8) &&
 782                     (coex_dm->pre_val_0x6cc == coex_dm->cur_val_0x6cc))
 783                         return;
 784         }
 785         btc8821a1ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
 786                                     val0x6c8, val0x6cc);
 787
 788         coex_dm->pre_val_0x6c0 = coex_dm->cur_val_0x6c0;
 789         coex_dm->pre_val_0x6c4 = coex_dm->cur_val_0x6c4;
 790         coex_dm->pre_val_0x6c8 = coex_dm->cur_val_0x6c8;
 791         coex_dm->pre_val_0x6cc = coex_dm->cur_val_0x6cc;
 792 }
 793
 794 static void btc8821a1ant_coex_table_with_type(struct btc_coexist *btcoexist,
 795                                               bool force_exec, u8 type)
 796 {
 797         switch (type) {
 798         case 0:
 799                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
 800                                         0x55555555, 0xffffff, 0x3);
 801                 break;
 802         case 1:
 803                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
 804                                         0x5a5a5a5a, 0xffffff, 0x3);
 805                 break;
 806         case 2:
 807                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 808                                         0x5a5a5a5a, 0xffffff, 0x3);
 809                 break;
 810         case 3:
 811                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 812                                         0xaaaaaaaa, 0xffffff, 0x3);
 813                 break;
 814         case 4:
 815                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
 816                                         0x5a5a5a5a, 0xffffff, 0x3);
 817                 break;
 818         case 5:
 819                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
 820                                         0xaaaa5a5a, 0xffffff, 0x3);
 821                 break;
 822         case 6:
 823                 btc8821a1ant_coex_table(btcoexist, force_exec, 0x55555555,
 824                                         0xaaaa5a5a, 0xffffff, 0x3);
 825                 break;
 826         case 7:
 827                 btc8821a1ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
 828                                         0xaaaaaaaa, 0xffffff, 0x3);
 829                 break;
 830         default:
 831                 break;
 832         }
 833 }
 834
 835 static void btc8821a1ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
 836                                                 bool enable)
 837 {
 838         struct rtl_priv *rtlpriv = btcoexist->adapter;
 839         u8 h2c_parameter[1] = {0};
 840
 841         if (enable)
 842                 h2c_parameter[0] |= BIT0; /* function enable */
 843
 844         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 845                  "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
 846                  h2c_parameter[0]);
 847
 848         btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
 849 }
 850
 851 static void btc8821a1ant_ignore_wlan_act(struct btc_coexist *btcoexist,
 852                                          bool force_exec, bool enable)
 853 {
 854         struct rtl_priv *rtlpriv = btcoexist->adapter;
 855
 856         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 857                  "[BTCoex], %s turn Ignore WlanAct %s\n",
 858                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
 859         coex_dm->cur_ignore_wlan_act = enable;
 860
 861         if (!force_exec) {
 862                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 863                          "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
 864                          coex_dm->pre_ignore_wlan_act,
 865                          coex_dm->cur_ignore_wlan_act);
 866
 867                 if (coex_dm->pre_ignore_wlan_act ==
 868                     coex_dm->cur_ignore_wlan_act)
 869                         return;
 870         }
 871         btc8821a1ant_set_fw_ignore_wlan_act(btcoexist, enable);
 872
 873         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
 874 }
 875
 876 static void btc8821a1ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
 877                                         u8 byte2, u8 byte3, u8 byte4, u8 byte5)
 878 {
 879         struct rtl_priv *rtlpriv = btcoexist->adapter;
 880         u8 h2c_parameter[5] = {0};
 881         u8 real_byte1 = byte1, real_byte5 = byte5;
 882         bool ap_enable = false;
 883
 884         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
 885                            &ap_enable);
 886
 887         if (ap_enable) {
 888                 if (byte1 & BIT4 && !(byte1 & BIT5)) {
 889                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 890                                  "[BTCoex], FW for 1Ant AP mode\n");
 891                         real_byte1 &= ~BIT4;
 892                         real_byte1 |= BIT5;
 893
 894                         real_byte5 |= BIT5;
 895                         real_byte5 &= ~BIT6;
 896                 }
 897         }
 898
 899         h2c_parameter[0] = real_byte1;
 900         h2c_parameter[1] = byte2;
 901         h2c_parameter[2] = byte3;
 902         h2c_parameter[3] = byte4;
 903         h2c_parameter[4] = real_byte5;
 904
 905         coex_dm->ps_tdma_para[0] = real_byte1;
 906         coex_dm->ps_tdma_para[1] = byte2;
 907         coex_dm->ps_tdma_para[2] = byte3;
 908         coex_dm->ps_tdma_para[3] = byte4;
 909         coex_dm->ps_tdma_para[4] = real_byte5;
 910
 911         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 912                  "[BTCoex], PS-TDMA H2C cmd =0x%x%08x\n",
 913                  h2c_parameter[0],
 914                  h2c_parameter[1] << 24 |
 915                  h2c_parameter[2] << 16 |
 916                  h2c_parameter[3] << 8 |
 917                  h2c_parameter[4]);
 918         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
 919 }
 920
 921 static void btc8821a1ant_set_lps_rpwm(struct btc_coexist *btcoexist,
 922                                       u8 lps_val, u8 rpwm_val)
 923 {
 924         u8 lps = lps_val;
 925         u8 rpwm = rpwm_val;
 926
 927         btcoexist->btc_set(btcoexist, BTC_SET_U1_LPS_VAL, &lps);
 928         btcoexist->btc_set(btcoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
 929 }
 930
 931 static void btc8821a1ant_lps_rpwm(struct btc_coexist *btcoexist,
 932                                   bool force_exec, u8 lps_val, u8 rpwm_val)
 933 {
 934         struct rtl_priv *rtlpriv = btcoexist->adapter;
 935
 936         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 937                  "[BTCoex], %s set lps/rpwm = 0x%x/0x%x\n",
 938                  (force_exec ? "force to" : ""), lps_val, rpwm_val);
 939         coex_dm->cur_lps = lps_val;
 940         coex_dm->cur_rpwm = rpwm_val;
 941
 942         if (!force_exec) {
 943                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 944                          "[BTCoex], LPS-RxBeaconMode = 0x%x, LPS-RPWM = 0x%x!!\n",
 945                          coex_dm->cur_lps, coex_dm->cur_rpwm);
 946
 947                 if ((coex_dm->pre_lps == coex_dm->cur_lps) &&
 948                     (coex_dm->pre_rpwm == coex_dm->cur_rpwm)) {
 949                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 950                                  "[BTCoex], LPS-RPWM_Last = 0x%x, LPS-RPWM_Now = 0x%x!!\n",
 951                                  coex_dm->pre_rpwm, coex_dm->cur_rpwm);
 952
 953                         return;
 954                 }
 955         }
 956         btc8821a1ant_set_lps_rpwm(btcoexist, lps_val, rpwm_val);
 957
 958         coex_dm->pre_lps = coex_dm->cur_lps;
 959         coex_dm->pre_rpwm = coex_dm->cur_rpwm;
 960 }
 961
 962 static void btc8821a1ant_sw_mechanism(struct btc_coexist *btcoexist,
 963                                       bool low_penalty_ra)
 964 {
 965         struct rtl_priv *rtlpriv = btcoexist->adapter;
 966
 967         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
 968                  "[BTCoex], SM[LpRA] = %d\n", low_penalty_ra);
 969
 970         btc8821a1ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
 971 }
 972
 973 static void btc8821a1ant_set_ant_path(struct btc_coexist *btcoexist,
 974                                       u8 ant_pos_type, bool init_hw_cfg,
 975                                       bool wifi_off)
 976 {
 977         struct btc_board_info *board_info = &btcoexist->board_info;
 978         u32 u4_tmp = 0;
 979         u8 h2c_parameter[2] = {0};
 980
 981         if (init_hw_cfg) {
 982                 /* 0x4c[23] = 0, 0x4c[24] = 1  Antenna control by WL/BT */
 983                 u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
 984                 u4_tmp &= ~BIT23;
 985                 u4_tmp |= BIT24;
 986                 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
 987
 988                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x975, 0x3, 0x3);
 989                 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
 990
 991                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
 992                         /* tell firmware "antenna inverse"
 993                          * WRONG firmware antenna control code, need fw to fix
 994                          */
 995                         h2c_parameter[0] = 1;
 996                         h2c_parameter[1] = 1;
 997                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
 998                                                 h2c_parameter);
 999                 } else {
1000                         /* tell firmware "no antenna inverse"
1001                          * WRONG firmware antenna control code, need fw to fix
1002                          */
1003                         h2c_parameter[0] = 0;
1004                         h2c_parameter[1] = 1;
1005                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1006                                                 h2c_parameter);
1007                 }
1008         } else if (wifi_off) {
1009                 /* 0x4c[24:23] = 00, Set Antenna control
1010                  * by BT_RFE_CTRL BT Vendor 0xac = 0xf002
1011                  */
1012                 u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1013                 u4_tmp &= ~BIT23;
1014                 u4_tmp &= ~BIT24;
1015                 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp);
1016
1017                 /* 0x765 = 0x18 */
1018                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x3);
1019         } else {
1020                 /* 0x765 = 0x0 */
1021                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
1022         }
1023
1024         /* ext switch setting */
1025         switch (ant_pos_type) {
1026         case BTC_ANT_PATH_WIFI:
1027                 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
1028                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1029                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1030                                                            0x30, 0x1);
1031                 else
1032                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1033                                                            0x30, 0x2);
1034                 break;
1035         case BTC_ANT_PATH_BT:
1036                 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
1037                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1038                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1039                                                            0x30, 0x2);
1040                 else
1041                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1042                                                            0x30, 0x1);
1043                 break;
1044         default:
1045         case BTC_ANT_PATH_PTA:
1046                 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x66);
1047                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT)
1048                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1049                                                            0x30, 0x1);
1050                 else
1051                         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7,
1052                                                            0x30, 0x2);
1053                 break;
1054         }
1055 }
1056
1057 static void btc8821a1ant_ps_tdma(struct btc_coexist *btcoexist,
1058                                  bool force_exec, bool turn_on, u8 type)
1059 {
1060         struct rtl_priv *rtlpriv = btcoexist->adapter;
1061         u8 rssi_adjust_val = 0;
1062
1063         coex_dm->cur_ps_tdma_on = turn_on;
1064         coex_dm->cur_ps_tdma = type;
1065
1066         if (!force_exec) {
1067                 if (coex_dm->cur_ps_tdma_on) {
1068                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1069                                  "[BTCoex], ********** TDMA(on, %d) **********\n",
1070                                  coex_dm->cur_ps_tdma);
1071                 } else {
1072                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1073                                  "[BTCoex], ********** TDMA(off, %d) **********\n",
1074                                  coex_dm->cur_ps_tdma);
1075                 }
1076                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1077                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1078                         return;
1079         }
1080         if (turn_on) {
1081                 switch (type) {
1082                 default:
1083                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1a,
1084                                                     0x1a, 0x0, 0x50);
1085                         break;
1086                 case 1:
1087                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x3a,
1088                                                     0x03, 0x10, 0x50);
1089                         rssi_adjust_val = 11;
1090                         break;
1091                 case 2:
1092                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x2b,
1093                                                     0x03, 0x10, 0x50);
1094                         rssi_adjust_val = 14;
1095                         break;
1096                 case 3:
1097                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1d,
1098                                                     0x1d, 0x0, 0x10);
1099                         break;
1100                 case 4:
1101                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1102                                                     0x3, 0x14, 0x0);
1103                         rssi_adjust_val = 17;
1104                         break;
1105                 case 5:
1106                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x15,
1107                                                     0x3, 0x11, 0x10);
1108                         break;
1109                 case 6:
1110                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x20,
1111                                                     0x3, 0x11, 0x13);
1112                         break;
1113                 case 7:
1114                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xc,
1115                                                     0x5, 0x0, 0x0);
1116                         break;
1117                 case 8:
1118                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1119                                                     0x3, 0x10, 0x0);
1120                         break;
1121                 case 9:
1122                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x21,
1123                                                     0x3, 0x10, 0x50);
1124                         rssi_adjust_val = 18;
1125                         break;
1126                 case 10:
1127                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1128                                                     0xa, 0x0, 0x40);
1129                         break;
1130                 case 11:
1131                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1132                                                     0x03, 0x10, 0x50);
1133                         rssi_adjust_val = 20;
1134                         break;
1135                 case 12:
1136                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x0a,
1137                                                     0x0a, 0x0, 0x50);
1138                         break;
1139                 case 13:
1140                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x12,
1141                                                     0x12, 0x0, 0x50);
1142                         break;
1143                 case 14:
1144                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x1e,
1145                                                     0x3, 0x10, 0x14);
1146                         break;
1147                 case 15:
1148                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x13, 0xa,
1149                                                     0x3, 0x8, 0x0);
1150                         break;
1151                 case 16:
1152                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x15,
1153                                                     0x3, 0x10, 0x0);
1154                         rssi_adjust_val = 18;
1155                         break;
1156                 case 18:
1157                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x93, 0x25,
1158                                                     0x3, 0x10, 0x0);
1159                         rssi_adjust_val = 14;
1160                         break;
1161                 case 20:
1162                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1163                                                     0x03, 0x11, 0x10);
1164                         break;
1165                 case 21:
1166                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1167                                                     0x03, 0x11, 0x11);
1168                         break;
1169                 case 22:
1170                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x25,
1171                                                     0x03, 0x11, 0x10);
1172                         break;
1173                 case 23:
1174                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1175                                                     0x3, 0x31, 0x18);
1176                         rssi_adjust_val = 22;
1177                         break;
1178                 case 24:
1179                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1180                                                     0x3, 0x31, 0x18);
1181                         rssi_adjust_val = 22;
1182                         break;
1183                 case 25:
1184                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1185                                                     0x3, 0x31, 0x18);
1186                         rssi_adjust_val = 22;
1187                         break;
1188                 case 26:
1189                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1190                                                     0x3, 0x31, 0x18);
1191                         rssi_adjust_val = 22;
1192                         break;
1193                 case 27:
1194                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1195                                                     0x3, 0x31, 0x98);
1196                         rssi_adjust_val = 22;
1197                         break;
1198                 case 28:
1199                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x69, 0x25,
1200                                                     0x3, 0x31, 0x0);
1201                         break;
1202                 case 29:
1203                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xab, 0x1a,
1204                                                     0x1a, 0x1, 0x10);
1205                         break;
1206                 case 30:
1207                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1208                                                     0x3, 0x10, 0x10);
1209                         break;
1210                 case 31:
1211                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x1a,
1212                                                     0x1a, 0, 0x58);
1213                         break;
1214                 case 32:
1215                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x61, 0x35,
1216                                                     0x3, 0x11, 0x11);
1217                         break;
1218                 case 33:
1219                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x25,
1220                                                     0x3, 0x30, 0x90);
1221                         break;
1222                 case 34:
1223                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x53, 0x1a,
1224                                                     0x1a, 0x0, 0x10);
1225                         break;
1226                 case 35:
1227                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x63, 0x1a,
1228                                                     0x1a, 0x0, 0x10);
1229                         break;
1230                 case 36:
1231                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0xd3, 0x12,
1232                                                     0x3, 0x14, 0x50);
1233                         break;
1234                 case 40:
1235                         /* SoftAP only with no sta associated, BT disable, TDMA
1236                          * mode for power saving
1237                          *
1238                          * here softap mode screen off will cost 70-80mA for
1239                          * phone
1240                          */
1241                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x23, 0x18,
1242                                                     0x00, 0x10, 0x24);
1243                         break;
1244                 case 41:
1245                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x15,
1246                                                     0x3, 0x11, 0x11);
1247                         break;
1248                 case 42:
1249                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x20,
1250                                                     0x3, 0x11, 0x11);
1251                         break;
1252                 case 43:
1253                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x51, 0x30,
1254                                                     0x3, 0x10, 0x11);
1255                         break;
1256                 }
1257         } else {
1258                 /* disable PS tdma */
1259                 switch (type) {
1260                 case 8:
1261                         /* PTA Control */
1262                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x8, 0x0, 0x0,
1263                                                     0x0, 0x0);
1264                         btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
1265                                                   false, false);
1266                         break;
1267                 case 0:
1268                 default:
1269                         /* Software control, Antenna at BT side */
1270                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1271                                                     0x0, 0x0);
1272                         btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1273                                                   false, false);
1274                         break;
1275                 case 9:
1276                         /* Software control, Antenna at WiFi side */
1277                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1278                                                     0x0, 0x0);
1279                         btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_WIFI,
1280                                                   false, false);
1281                         break;
1282                 case 10:
1283                         /* under 5G */
1284                         btc8821a1ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1285                                                     0x8, 0x0);
1286                         btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
1287                                                   false, false);
1288                         break;
1289                 }
1290         }
1291         rssi_adjust_val = 0;
1292         btcoexist->btc_set(btcoexist,
1293                  BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val);
1294
1295         /* update pre state */
1296         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1297         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1298 }
1299
1300 static bool btc8821a1ant_is_common_action(struct btc_coexist *btcoexist)
1301 {
1302         struct rtl_priv *rtlpriv = btcoexist->adapter;
1303         bool common = false, wifi_connected = false, wifi_busy = false;
1304
1305         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1306                            &wifi_connected);
1307         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1308
1309         if (!wifi_connected &&
1310             BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1311             coex_dm->bt_status) {
1312                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1313                          "[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n");
1314                 btc8821a1ant_sw_mechanism(btcoexist, false);
1315
1316                 common = true;
1317         } else if (wifi_connected &&
1318                    (BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1319                     coex_dm->bt_status)) {
1320                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1321                          "[BTCoex], Wifi connected + BT non connected-idle!!\n");
1322                 btc8821a1ant_sw_mechanism(btcoexist, false);
1323
1324                 common = true;
1325         } else if (!wifi_connected &&
1326                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1327                     coex_dm->bt_status)) {
1328                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1329                          "[BTCoex], Wifi non connected-idle + BT connected-idle!!\n");
1330                 btc8821a1ant_sw_mechanism(btcoexist, false);
1331
1332                 common = true;
1333         } else if (wifi_connected &&
1334                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
1335                     coex_dm->bt_status)) {
1336                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1337                          "[BTCoex], Wifi connected + BT connected-idle!!\n");
1338                 btc8821a1ant_sw_mechanism(btcoexist, false);
1339
1340                 common = true;
1341         } else if (!wifi_connected &&
1342                    (BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE !=
1343                     coex_dm->bt_status)) {
1344                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1345                          "[BTCoex], Wifi non connected-idle + BT Busy!!\n");
1346                 btc8821a1ant_sw_mechanism(btcoexist, false);
1347
1348                 common = true;
1349         } else {
1350                 if (wifi_busy) {
1351                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1352                                  "[BTCoex], Wifi Connected-Busy + BT Busy!!\n");
1353                 } else {
1354                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1355                                  "[BTCoex], Wifi Connected-Idle + BT Busy!!\n");
1356                 }
1357
1358                 common = false;
1359         }
1360
1361         return common;
1362 }
1363
1364 static void btc8821a1ant_ps_tdma_check_for_pwr_save(struct btc_coexist *btcoex,
1365                                                     bool new_ps_state)
1366 {
1367         u8 lps_mode = 0x0;
1368
1369         btcoex->btc_get(btcoex, BTC_GET_U1_LPS_MODE, &lps_mode);
1370
1371         if (lps_mode) {
1372                 /* already under LPS state */
1373                 if (new_ps_state) {
1374                         /* keep state under LPS, do nothing */
1375                 } else {
1376                         /* will leave LPS state, turn off psTdma first */
1377                         btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1378                 }
1379         } else {
1380                 /* NO PS state*/
1381                 if (new_ps_state) {
1382                         /* will enter LPS state, turn off psTdma first */
1383                         btc8821a1ant_ps_tdma(btcoex, NORMAL_EXEC, false, 0);
1384                 } else {
1385                         /* keep state under NO PS state, do nothing */
1386                 }
1387         }
1388 }
1389
1390 static void btc8821a1ant_power_save_state(struct btc_coexist *btcoexist,
1391                                           u8 ps_type, u8 lps_val, u8 rpwm_val)
1392 {
1393         bool low_pwr_disable = false;
1394
1395         switch (ps_type) {
1396         case BTC_PS_WIFI_NATIVE:
1397                 /* recover to original 32k low power setting */
1398                 low_pwr_disable = false;
1399                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1400                                    &low_pwr_disable);
1401                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1402                 break;
1403         case BTC_PS_LPS_ON:
1404                 btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist,
1405                                                         true);
1406                 btc8821a1ant_lps_rpwm(btcoexist, NORMAL_EXEC, lps_val,
1407                                       rpwm_val);
1408                 /* when coex force to enter LPS, do not enter 32k low power */
1409                 low_pwr_disable = true;
1410                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1411                                    &low_pwr_disable);
1412                 /* power save must executed before psTdma */
1413                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1414                 break;
1415         case BTC_PS_LPS_OFF:
1416                 btc8821a1ant_ps_tdma_check_for_pwr_save(btcoexist, false);
1417                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1418                 break;
1419         default:
1420                 break;
1421         }
1422 }
1423
1424 static void btc8821a1ant_coex_under_5g(struct btc_coexist *btcoexist)
1425 {
1426         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1427                                       0x0, 0x0);
1428         btc8821a1ant_ignore_wlan_act(btcoexist, NORMAL_EXEC, true);
1429
1430         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 10);
1431
1432         btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1433
1434         btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
1435
1436         btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false, false, 5);
1437 }
1438
1439 /***********************************************
1440  *
1441  *      Software Coex Mechanism start
1442  *
1443  ***********************************************/
1444
1445 /* SCO only or SCO+PAN(HS) */
1446 static void btc8821a1ant_action_sco(struct btc_coexist *btcoexist)
1447 {
1448         btc8821a1ant_sw_mechanism(btcoexist, true);
1449 }
1450
1451 static void btc8821a1ant_action_hid(struct btc_coexist *btcoexist)
1452 {
1453         btc8821a1ant_sw_mechanism(btcoexist, true);
1454 }
1455
1456 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
1457 static void btc8821a1ant_action_a2dp(struct btc_coexist *btcoexist)
1458 {
1459         btc8821a1ant_sw_mechanism(btcoexist, false);
1460 }
1461
1462 static void btc8821a1ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
1463 {
1464         btc8821a1ant_sw_mechanism(btcoexist, false);
1465 }
1466
1467 static void btc8821a1ant_action_pan_edr(struct btc_coexist *btcoexist)
1468 {
1469         btc8821a1ant_sw_mechanism(btcoexist, false);
1470 }
1471
1472 /* PAN(HS) only */
1473 static void btc8821a1ant_action_pan_hs(struct btc_coexist *btcoexist)
1474 {
1475         btc8821a1ant_sw_mechanism(btcoexist, false);
1476 }
1477
1478 /* PAN(EDR)+A2DP */
1479 static void btc8821a1ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
1480 {
1481         btc8821a1ant_sw_mechanism(btcoexist, false);
1482 }
1483
1484 static void btc8821a1ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
1485 {
1486         btc8821a1ant_sw_mechanism(btcoexist, true);
1487 }
1488
1489 /* HID+A2DP+PAN(EDR) */
1490 static void btc8821a1ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
1491 {
1492         btc8821a1ant_sw_mechanism(btcoexist, true);
1493 }
1494
1495 static void btc8821a1ant_action_hid_a2dp(struct btc_coexist *btcoexist)
1496 {
1497         btc8821a1ant_sw_mechanism(btcoexist, true);
1498 }
1499
1500 /***********************************************
1501  *
1502  *      Non-Software Coex Mechanism start
1503  *
1504  ***********************************************/
1505 static
1506 void btc8821a1ant_action_wifi_multi_port(struct btc_coexist *btcoexist)
1507 {
1508         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1509
1510         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1511         /* tdma and coex table */
1512         if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1513                 if (bt_link_info->a2dp_exist) {
1514                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1515                         btc8821a1ant_coex_table_with_type(btcoexist,
1516                                                           NORMAL_EXEC, 1);
1517                 } else if (bt_link_info->a2dp_exist &&
1518                            bt_link_info->pan_exist) {
1519                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1520                         btc8821a1ant_coex_table_with_type(btcoexist,
1521                                                           NORMAL_EXEC, 4);
1522                 } else {
1523                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1524                         btc8821a1ant_coex_table_with_type(btcoexist,
1525                                                           NORMAL_EXEC, 4);
1526                 }
1527         } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1528                    (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1529                     coex_dm->bt_status)) {
1530                 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1531                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1532         } else {
1533                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1534                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1535         }
1536 }
1537
1538 static
1539 void btc8821a1ant_action_wifi_not_connected_asso_auth(
1540                                         struct btc_coexist *btcoexist)
1541 {
1542         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1543
1544         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0,
1545                                       0x0);
1546
1547         /* tdma and coex table */
1548         if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist)) {
1549                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1550                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1551         } else if ((bt_link_info->a2dp_exist) || (bt_link_info->pan_exist)) {
1552                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1553                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1554         } else {
1555                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1556                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1557         }
1558 }
1559
1560
1561 static void btc8821a1ant_action_hs(struct btc_coexist *btcoexist)
1562 {
1563         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1564         btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 2);
1565 }
1566
1567 static void btc8821a1ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1568 {
1569         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1570         bool wifi_connected = false;
1571         bool ap_enable = false;
1572         bool wifi_busy = false, bt_busy = false;
1573
1574         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1575                            &wifi_connected);
1576         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1577                            &ap_enable);
1578         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1579         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1580
1581         if (!wifi_connected && !coex_sta->wifi_is_high_pri_task) {
1582                 btc8821a1ant_power_save_state(btcoexist,
1583                                               BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1584                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1585                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1586         } else if ((bt_link_info->sco_exist) || (bt_link_info->a2dp_exist) ||
1587                    (bt_link_info->hid_only)) {
1588                 /* SCO/HID-only busy */
1589                 btc8821a1ant_power_save_state(btcoexist,
1590                                               BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1591                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1592                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1593         } else if ((bt_link_info->a2dp_exist) && (bt_link_info->hid_exist)) {
1594                 /* A2DP+HID busy */
1595                 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1596                                               0x0, 0x0);
1597                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1598
1599                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1600         } else if ((bt_link_info->pan_exist) || (wifi_busy)) {
1601                 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1602                                               0x0, 0x0);
1603                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1604
1605                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1606         } else {
1607                 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1608                                               0x0, 0x0);
1609                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1610                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 7);
1611         }
1612 }
1613
1614 static void btc8821a1ant_act_bt_sco_hid_only_busy(struct btc_coexist *btcoexist,
1615                                                   u8 wifi_status)
1616 {
1617         /* tdma and coex table */
1618         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
1619
1620         if (BT_8821A_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN ==
1621             wifi_status)
1622                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1623         else
1624                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1625 }
1626
1627 static void btc8821a1ant_act_wifi_con_bt_acl_busy(struct btc_coexist *btcoexist,
1628                                                   u8 wifi_status)
1629 {
1630         u8 bt_rssi_state;
1631
1632         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1633
1634         bt_rssi_state = btc8821a1ant_bt_rssi_state(btcoexist, 2, 28, 0);
1635
1636         if (bt_link_info->hid_only) {
1637                 /* HID */
1638                 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1639                                                       wifi_status);
1640                 coex_dm->auto_tdma_adjust = false;
1641                 return;
1642         } else if (bt_link_info->a2dp_only) {
1643                 /* A2DP */
1644                 if (wifi_status == BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1645                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1646                         btc8821a1ant_coex_table_with_type(btcoexist,
1647                                                           NORMAL_EXEC, 1);
1648                         coex_dm->auto_tdma_adjust = false;
1649                 } else if ((bt_rssi_state != BTC_RSSI_STATE_HIGH) &&
1650                            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
1651                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1652                         btc8821a1ant_coex_table_with_type(btcoexist,
1653                                                           NORMAL_EXEC, 1);
1654                 } else {
1655                         /* for low BT RSSI */
1656                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1657                         btc8821a1ant_coex_table_with_type(btcoexist,
1658                                                           NORMAL_EXEC, 1);
1659                         coex_dm->auto_tdma_adjust = false;
1660                 }
1661         } else if (bt_link_info->hid_exist && bt_link_info->a2dp_exist) {
1662                 /* HID+A2DP */
1663                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
1664                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
1665                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1666                                              true, 14);
1667                         coex_dm->auto_tdma_adjust = false;
1668                 } else {
1669                         /*for low BT RSSI*/
1670                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC,
1671                                              true, 14);
1672                         coex_dm->auto_tdma_adjust = false;
1673                 }
1674
1675                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1676         } else if ((bt_link_info->pan_only) ||
1677                 (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
1678                 /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
1679                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1680                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 6);
1681                 coex_dm->auto_tdma_adjust = false;
1682         } else if (((bt_link_info->a2dp_exist) && (bt_link_info->pan_exist)) ||
1683                    (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
1684                     bt_link_info->pan_exist)) {
1685                 /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
1686                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 43);
1687                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1688                 coex_dm->auto_tdma_adjust = false;
1689         } else {
1690                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1691                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1692                 coex_dm->auto_tdma_adjust = false;
1693         }
1694 }
1695
1696 static
1697 void btc8821a1ant_action_wifi_not_connected(struct btc_coexist *btcoexist)
1698 {
1699         /* power save state */
1700         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1701
1702         /* tdma and coex table */
1703         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1704         btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 0);
1705 }
1706
1707 static void btc8821a1ant_act_wifi_not_conn_scan(struct btc_coexist *btcoexist)
1708 {
1709         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1710
1711         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1712
1713         /* tdma and coex table */
1714         if (coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_ACL_BUSY) {
1715                 if (bt_link_info->a2dp_exist) {
1716                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1717                         btc8821a1ant_coex_table_with_type(btcoexist,
1718                                                           NORMAL_EXEC, 1);
1719                 } else if (bt_link_info->a2dp_exist &&
1720                            bt_link_info->pan_exist) {
1721                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 22);
1722                         btc8821a1ant_coex_table_with_type(btcoexist,
1723                                                           NORMAL_EXEC, 4);
1724                 } else {
1725                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1726                         btc8821a1ant_coex_table_with_type(btcoexist,
1727                                                           NORMAL_EXEC, 4);
1728                 }
1729         } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1730                    (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1731                     coex_dm->bt_status)) {
1732                 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1733                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1734         } else {
1735                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1736                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1737         }
1738 }
1739
1740 static
1741 void btc8821a1ant_action_wifi_connected_scan(struct btc_coexist *btcoexist)
1742 {
1743         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1744
1745         /* power save state */
1746         btc8821a1ant_power_save_state(btcoexist,
1747                                       BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1748
1749         /* tdma and coex table */
1750         if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1751                 if (bt_link_info->a2dp_exist) {
1752                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1753                         btc8821a1ant_coex_table_with_type(btcoexist,
1754                                                           NORMAL_EXEC, 1);
1755                 } else {
1756                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1757                         btc8821a1ant_coex_table_with_type(btcoexist,
1758                                                           NORMAL_EXEC, 4);
1759                 }
1760         } else if ((coex_dm->bt_status == BT_8821A_1ANT_BT_STATUS_SCO_BUSY) ||
1761                    (coex_dm->bt_status ==
1762                     BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY)) {
1763                 btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1764                         BT_8821A_1ANT_WIFI_STATUS_CONNECTED_SCAN);
1765         } else {
1766                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1767                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1768         }
1769 }
1770
1771 static void btc8821a1ant_act_wifi_conn_sp_pkt(struct btc_coexist *btcoexist)
1772 {
1773         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1774
1775         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
1776                                       0x0, 0x0);
1777
1778         /* tdma and coex table */
1779         if ((bt_link_info->sco_exist) || (bt_link_info->hid_exist) ||
1780             (bt_link_info->a2dp_exist)) {
1781                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 32);
1782                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1783         }
1784
1785         if ((bt_link_info->hid_exist) && (bt_link_info->a2dp_exist)) {
1786                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1787                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 1);
1788         } else if (bt_link_info->pan_exist) {
1789                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 20);
1790                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 4);
1791         } else {
1792                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1793                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
1794         }
1795 }
1796
1797 static void btc8821a1ant_action_wifi_connected(struct btc_coexist *btcoexist)
1798 {
1799         struct rtl_priv *rtlpriv = btcoexist->adapter;
1800         bool wifi_busy = false;
1801         bool scan = false, link = false, roam = false;
1802         bool under_4way = false;
1803         bool ap_enable = false;
1804
1805         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1806                  "[BTCoex], CoexForWifiConnect()===>\n");
1807
1808         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
1809                            &under_4way);
1810         if (under_4way) {
1811                 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1812                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1813                          "[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n");
1814                 return;
1815         }
1816
1817         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
1818         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
1819         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
1820         if (scan || link || roam) {
1821                 if (scan)
1822                         btc8821a1ant_action_wifi_connected_scan(btcoexist);
1823                 else
1824                         btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
1825
1826                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1827                          "[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n");
1828                 return;
1829         }
1830
1831         /* power save state*/
1832         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE,
1833                            &ap_enable);
1834         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1835         if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY ==
1836             coex_dm->bt_status && !ap_enable &&
1837             !btcoexist->bt_link_info.hid_only) {
1838                 if (!wifi_busy && btcoexist->bt_link_info.a2dp_only)
1839                         /* A2DP */
1840                         btc8821a1ant_power_save_state(btcoexist,
1841                                                 BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1842                 else
1843                         btc8821a1ant_power_save_state(btcoexist, BTC_PS_LPS_ON,
1844                                                       0x50, 0x4);
1845         } else {
1846                 btc8821a1ant_power_save_state(btcoexist,
1847                                               BTC_PS_WIFI_NATIVE,
1848                                               0x0, 0x0);
1849         }
1850
1851         /* tdma and coex table */
1852         if (!wifi_busy) {
1853                 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1854                         btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1855                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1856                 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1857                             coex_dm->bt_status) ||
1858                            (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1859                             coex_dm->bt_status)) {
1860                         btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1861                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1862                 } else {
1863                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1864                         btc8821a1ant_coex_table_with_type(btcoexist,
1865                                                           NORMAL_EXEC, 2);
1866                 }
1867         } else {
1868                 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) {
1869                         btc8821a1ant_act_wifi_con_bt_acl_busy(btcoexist,
1870                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1871                 } else if ((BT_8821A_1ANT_BT_STATUS_SCO_BUSY ==
1872                             coex_dm->bt_status) ||
1873                            (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY ==
1874                             coex_dm->bt_status)) {
1875                         btc8821a1ant_act_bt_sco_hid_only_busy(btcoexist,
1876                                 BT_8821A_1ANT_WIFI_STATUS_CONNECTED_BUSY);
1877                 } else {
1878                         btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 8);
1879                         btc8821a1ant_coex_table_with_type(btcoexist,
1880                                                           NORMAL_EXEC, 2);
1881                 }
1882         }
1883 }
1884
1885 static void btc8821a1ant_run_sw_coex_mech(struct btc_coexist *btcoexist)
1886 {
1887         struct rtl_priv *rtlpriv = btcoexist->adapter;
1888         u8 algorithm = 0;
1889
1890         algorithm = btc8821a1ant_action_algorithm(btcoexist);
1891         coex_dm->cur_algorithm = algorithm;
1892
1893         if (!btc8821a1ant_is_common_action(btcoexist)) {
1894                 switch (coex_dm->cur_algorithm) {
1895                 case BT_8821A_1ANT_COEX_ALGO_SCO:
1896                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1897                                  "[BTCoex], Action algorithm = SCO\n");
1898                         btc8821a1ant_action_sco(btcoexist);
1899                         break;
1900                 case BT_8821A_1ANT_COEX_ALGO_HID:
1901                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1902                                  "[BTCoex], Action algorithm = HID\n");
1903                         btc8821a1ant_action_hid(btcoexist);
1904                         break;
1905                 case BT_8821A_1ANT_COEX_ALGO_A2DP:
1906                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1907                                  "[BTCoex], Action algorithm = A2DP\n");
1908                         btc8821a1ant_action_a2dp(btcoexist);
1909                         break;
1910                 case BT_8821A_1ANT_COEX_ALGO_A2DP_PANHS:
1911                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1912                                  "[BTCoex], Action algorithm = A2DP+PAN(HS)\n");
1913                         btc8821a1ant_action_a2dp_pan_hs(btcoexist);
1914                         break;
1915                 case BT_8821A_1ANT_COEX_ALGO_PANEDR:
1916                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1917                                  "[BTCoex], Action algorithm = PAN(EDR)\n");
1918                         btc8821a1ant_action_pan_edr(btcoexist);
1919                         break;
1920                 case BT_8821A_1ANT_COEX_ALGO_PANHS:
1921                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1922                                  "[BTCoex], Action algorithm = HS mode\n");
1923                         btc8821a1ant_action_pan_hs(btcoexist);
1924                         break;
1925                 case BT_8821A_1ANT_COEX_ALGO_PANEDR_A2DP:
1926                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1927                                  "[BTCoex], Action algorithm = PAN+A2DP\n");
1928                         btc8821a1ant_action_pan_edr_a2dp(btcoexist);
1929                         break;
1930                 case BT_8821A_1ANT_COEX_ALGO_PANEDR_HID:
1931                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1932                                  "[BTCoex], Action algorithm = PAN(EDR)+HID\n");
1933                         btc8821a1ant_action_pan_edr_hid(btcoexist);
1934                         break;
1935                 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
1936                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1937                                  "[BTCoex], Action algorithm = HID+A2DP+PAN\n");
1938                         btc8821a1ant_action_hid_a2dp_pan_edr(btcoexist);
1939                         break;
1940                 case BT_8821A_1ANT_COEX_ALGO_HID_A2DP:
1941                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1942                                  "[BTCoex], Action algorithm = HID+A2DP\n");
1943                         btc8821a1ant_action_hid_a2dp(btcoexist);
1944                         break;
1945                 default:
1946                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1947                                  "[BTCoex], Action algorithm = coexist All Off!!\n");
1948                         /*btc8821a1ant_coex_all_off(btcoexist);*/
1949                         break;
1950                 }
1951                 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
1952         }
1953 }
1954
1955 static void btc8821a1ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
1956 {
1957         struct rtl_priv *rtlpriv = btcoexist->adapter;
1958         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
1959         bool wifi_connected = false, bt_hs_on = false;
1960         bool increase_scan_dev_num = false;
1961         bool bt_ctrl_agg_buf_size = false;
1962         u8 agg_buf_size = 5;
1963         u8 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
1964         u32 wifi_link_status = 0;
1965         u32 num_of_wifi_link = 0;
1966         bool wifi_under_5g = false;
1967
1968         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1969                  "[BTCoex], RunCoexistMechanism()===>\n");
1970
1971         if (btcoexist->manual_control) {
1972                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1973                          "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
1974                 return;
1975         }
1976
1977         if (btcoexist->stop_coex_dm) {
1978                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1979                          "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
1980                 return;
1981         }
1982
1983         if (coex_sta->under_ips) {
1984                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1985                          "[BTCoex], wifi is under IPS !!!\n");
1986                 return;
1987         }
1988
1989         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
1990         if (wifi_under_5g) {
1991                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
1992                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
1993                 btc8821a1ant_coex_under_5g(btcoexist);
1994                 return;
1995         }
1996
1997         if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
1998             (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
1999             (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
2000                 increase_scan_dev_num = true;
2001
2002         btcoexist->btc_set(btcoexist, BTC_SET_BL_INC_SCAN_DEV_NUM,
2003                            &increase_scan_dev_num);
2004
2005         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2006                            &wifi_connected);
2007
2008         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2009                            &wifi_link_status);
2010         num_of_wifi_link = wifi_link_status >> 16;
2011         if ((num_of_wifi_link >= 2) ||
2012             (wifi_link_status & WIFI_P2P_GO_CONNECTED)) {
2013                 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2014                 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2015                                         bt_ctrl_agg_buf_size, agg_buf_size);
2016                 btc8821a1ant_action_wifi_multi_port(btcoexist);
2017                 return;
2018         }
2019
2020         if (!bt_link_info->sco_exist && !bt_link_info->hid_exist) {
2021                 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2022         } else {
2023                 if (wifi_connected) {
2024                         wifi_rssi_state =
2025                                 btc8821a1ant_wifi_rssi_state(btcoexist, 1, 2,
2026                                                              30, 0);
2027                         if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2028                             (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2029                                 btc8821a1ant_limited_tx(btcoexist,
2030                                                         NORMAL_EXEC, 1, 1,
2031                                                         0, 1);
2032                         } else {
2033                                 btc8821a1ant_limited_tx(btcoexist,
2034                                                         NORMAL_EXEC, 1, 1,
2035                                                         0, 1);
2036                         }
2037                 } else {
2038                         btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC,
2039                                                 0, 0, 0, 0);
2040                 }
2041         }
2042
2043         if (bt_link_info->sco_exist) {
2044                 bt_ctrl_agg_buf_size = true;
2045                 agg_buf_size = 0x3;
2046         } else if (bt_link_info->hid_exist) {
2047                 bt_ctrl_agg_buf_size = true;
2048                 agg_buf_size = 0x5;
2049         } else if (bt_link_info->a2dp_exist || bt_link_info->pan_exist) {
2050                 bt_ctrl_agg_buf_size = true;
2051                 agg_buf_size = 0x8;
2052         }
2053         btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2054                                 bt_ctrl_agg_buf_size, agg_buf_size);
2055
2056         btc8821a1ant_run_sw_coex_mech(btcoexist);
2057
2058         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2059         if (coex_sta->c2h_bt_inquiry_page) {
2060                 btc8821a1ant_action_bt_inquiry(btcoexist);
2061                 return;
2062         } else if (bt_hs_on) {
2063                 btc8821a1ant_action_hs(btcoexist);
2064                 return;
2065         }
2066
2067         if (!wifi_connected) {
2068                 bool scan = false, link = false, roam = false;
2069
2070                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2071                          "[BTCoex], wifi is non connected-idle !!!\n");
2072
2073                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2074                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2075                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2076
2077                 if (scan || link || roam) {
2078                         if (scan)
2079                                 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2080                         else
2081                                 btc8821a1ant_action_wifi_not_connected_asso_auth(
2082                                         btcoexist);
2083                 } else {
2084                         btc8821a1ant_action_wifi_not_connected(btcoexist);
2085                 }
2086         } else {
2087                 /* wifi LPS/Busy */
2088                 btc8821a1ant_action_wifi_connected(btcoexist);
2089         }
2090 }
2091
2092 static void btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2093 {
2094         /* force to reset coex mechanism
2095          * sw all off
2096          */
2097         btc8821a1ant_sw_mechanism(btcoexist, false);
2098
2099         btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2100 }
2101
2102 static void btc8821a1ant_init_hw_config(struct btc_coexist *btcoexist,
2103                                         bool back_up, bool wifi_only)
2104 {
2105         struct rtl_priv *rtlpriv = btcoexist->adapter;
2106         u8 u1_tmp = 0;
2107         bool wifi_under_5g = false;
2108
2109         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2110                  "[BTCoex], 1Ant Init HW Config!!\n");
2111
2112         if (wifi_only)
2113                 return;
2114
2115         if (back_up) {
2116                 coex_dm->backup_arfr_cnt1 = btcoexist->btc_read_4byte(btcoexist,
2117                                                                       0x430);
2118                 coex_dm->backup_arfr_cnt2 = btcoexist->btc_read_4byte(btcoexist,
2119                                                                       0x434);
2120                 coex_dm->backup_retry_limit =
2121                         btcoexist->btc_read_2byte(btcoexist, 0x42a);
2122                 coex_dm->backup_ampdu_max_time =
2123                         btcoexist->btc_read_1byte(btcoexist, 0x456);
2124         }
2125
2126         /* 0x790[5:0] = 0x5 */
2127         u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
2128         u1_tmp &= 0xc0;
2129         u1_tmp |= 0x5;
2130         btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp);
2131
2132         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2133
2134         /* Antenna config */
2135         if (wifi_under_5g)
2136                 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT,
2137                                           true, false);
2138         else
2139                 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_PTA,
2140                                           true, false);
2141         /* PTA parameter */
2142         btc8821a1ant_coex_table_with_type(btcoexist, FORCE_EXEC, 0);
2143
2144         /* Enable counter statistics
2145          * 0x76e[3] =1, WLAN_Act control by PTA
2146          */
2147         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
2148         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
2149         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
2150 }
2151
2152 /**************************************************************
2153  * extern function start with ex_btc8821a1ant_
2154  **************************************************************/
2155 void ex_btc8821a1ant_init_hwconfig(struct btc_coexist *btcoexist, bool wifionly)
2156 {
2157         btc8821a1ant_init_hw_config(btcoexist, true, wifionly);
2158         btcoexist->auto_report_1ant = true;
2159 }
2160
2161 void ex_btc8821a1ant_init_coex_dm(struct btc_coexist *btcoexist)
2162 {
2163         struct rtl_priv *rtlpriv = btcoexist->adapter;
2164
2165         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2166                  "[BTCoex], Coex Mechanism Init!!\n");
2167
2168         btcoexist->stop_coex_dm = false;
2169
2170         btc8821a1ant_init_coex_dm(btcoexist);
2171
2172         btc8821a1ant_query_bt_info(btcoexist);
2173 }
2174
2175 void ex_btc8821a1ant_display_coex_info(struct btc_coexist *btcoexist)
2176 {
2177         struct btc_board_info *board_info = &btcoexist->board_info;
2178         struct btc_stack_info *stack_info = &btcoexist->stack_info;
2179         struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
2180         struct rtl_priv *rtlpriv = btcoexist->adapter;
2181         u8 u1_tmp[4], i, bt_info_ext, ps_tdma_case = 0;
2182         u16 u2_tmp[4];
2183         u32 u4_tmp[4];
2184         bool roam = false, scan = false, link = false, wifi_under_5g = false;
2185         bool bt_hs_on = false, wifi_busy = false;
2186         long wifi_rssi = 0, bt_hs_rssi = 0;
2187         u32 wifi_bw, wifi_traffic_dir;
2188         u8 wifi_dot11_chnl, wifi_hs_chnl;
2189         u32 fw_ver = 0, bt_patch_ver = 0;
2190
2191         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2192                  "\r\n ============[BT Coexist info]============");
2193
2194         if (btcoexist->manual_control) {
2195                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2196                          "\r\n ============[Under Manual Control]============");
2197                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2198                          "\r\n ==========================================");
2199         }
2200         if (btcoexist->stop_coex_dm) {
2201                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2202                          "\r\n ============[Coex is STOPPED]============");
2203                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2204                          "\r\n ==========================================");
2205         }
2206
2207         if (!board_info->bt_exist) {
2208                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
2209                 return;
2210         }
2211
2212         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2213                  "\r\n %-35s = %d/ %d/ %d",
2214                  "Ant PG Num/ Ant Mech/ Ant Pos:",
2215                  board_info->pg_ant_num,
2216                  board_info->btdm_ant_num,
2217                  board_info->btdm_ant_pos);
2218
2219         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2220                  "\r\n %-35s = %s / %d", "BT stack/ hci ext ver",
2221                  ((stack_info->profile_notified) ? "Yes" : "No"),
2222                  stack_info->hci_version);
2223
2224         btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
2225                            &bt_patch_ver);
2226         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
2227         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2228                  "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
2229                  "CoexVer/ FwVer/ PatchVer",
2230                  glcoex_ver_date_8821a_1ant,
2231                  glcoex_ver_8821a_1ant,
2232                  fw_ver, bt_patch_ver,
2233                  bt_patch_ver);
2234
2235         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION,
2236                            &bt_hs_on);
2237         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
2238                            &wifi_dot11_chnl);
2239         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL,
2240                            &wifi_hs_chnl);
2241         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2242                  "\r\n %-35s = %d / %d(%d)",
2243                  "Dot11 channel / HsChnl(HsMode)",
2244                  wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
2245
2246         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2247                  "\r\n %-35s = %3ph ",
2248                  "H2C Wifi inform bt chnl Info",
2249                  coex_dm->wifi_chnl_info);
2250
2251         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
2252         btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
2253         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2254                  "\r\n %-35s = %d/ %d", "Wifi rssi/ HS rssi",
2255                  (int)wifi_rssi, (int)bt_hs_rssi);
2256
2257         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2258         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2259         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2260         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2261                  "\r\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
2262                  link, roam, scan);
2263
2264         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G,
2265                            &wifi_under_5g);
2266         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW,
2267                            &wifi_bw);
2268         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY,
2269                            &wifi_busy);
2270         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
2271                            &wifi_traffic_dir);
2272         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2273                  "\r\n %-35s = %s / %s/ %s ", "Wifi status",
2274                  (wifi_under_5g ? "5G" : "2.4G"),
2275                  ((wifi_bw == BTC_WIFI_BW_LEGACY) ? "Legacy" :
2276                  (((wifi_bw == BTC_WIFI_BW_HT40) ? "HT40" : "HT20"))),
2277                  ((!wifi_busy) ? "idle" :
2278                  ((wifi_traffic_dir == BTC_WIFI_TRAFFIC_TX) ?
2279                  "uplink" : "downlink")));
2280         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2281                    "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]",
2282                    ((coex_sta->bt_disabled) ? ("disabled") :
2283                    ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
2284                    ((BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE ==
2285                      coex_dm->bt_status) ?
2286                    "non-connected idle" :
2287                    ((BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE ==
2288                      coex_dm->bt_status) ?
2289                    "connected-idle" : "busy")))),
2290                    coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
2291
2292         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2293                  "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
2294                  bt_link_info->sco_exist,
2295                  bt_link_info->hid_exist,
2296                  bt_link_info->pan_exist,
2297                  bt_link_info->a2dp_exist);
2298         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
2299
2300         bt_info_ext = coex_sta->bt_info_ext;
2301         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2302                  "\r\n %-35s = %s",
2303                  "BT Info A2DP rate",
2304                  (bt_info_ext & BIT0) ?
2305                  "Basic rate" : "EDR rate");
2306
2307         for (i = 0; i < BT_INFO_SRC_8821A_1ANT_MAX; i++) {
2308                 if (coex_sta->bt_info_c2h_cnt[i]) {
2309                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2310                                  "\r\n %-35s = %7ph(%d)",
2311                                  glbt_info_src_8821a_1ant[i],
2312                                  coex_sta->bt_info_c2h[i],
2313                                  coex_sta->bt_info_c2h_cnt[i]);
2314                 }
2315         }
2316         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2317                  "\r\n %-35s = %s/%s, (0x%x/0x%x)",
2318                  "PS state, IPS/LPS, (lps/rpwm)",
2319                  ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
2320                  ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")),
2321                  btcoexist->bt_info.lps_val,
2322                  btcoexist->bt_info.rpwm_val);
2323         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
2324
2325         if (!btcoexist->manual_control) {
2326                 /* Sw mechanism*/
2327                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2328                          "\r\n %-35s",
2329                          "============[Sw mechanism]============");
2330
2331                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2332                          "\r\n %-35s = %d", "SM[LowPenaltyRA]",
2333                          coex_dm->cur_low_penalty_ra);
2334
2335                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2336                          "\r\n %-35s = %s/ %s/ %d ",
2337                          "DelBA/ BtCtrlAgg/ AggSize",
2338                          (btcoexist->bt_info.reject_agg_pkt ? "Yes" : "No"),
2339                          (btcoexist->bt_info.bt_ctrl_buf_size ? "Yes" : "No"),
2340                          btcoexist->bt_info.agg_buf_size);
2341                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2342                          "\r\n %-35s = 0x%x ", "Rate Mask",
2343                          btcoexist->bt_info.ra_mask);
2344
2345                 /* Fw mechanism */
2346                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
2347                          "============[Fw mechanism]============");
2348
2349                 ps_tdma_case = coex_dm->cur_ps_tdma;
2350                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2351                          "\r\n %-35s = %5ph case-%d (auto:%d)",
2352                          "PS TDMA",
2353                          coex_dm->ps_tdma_para,
2354                          ps_tdma_case,
2355                          coex_dm->auto_tdma_adjust);
2356
2357                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2358                          "\r\n %-35s = 0x%x ",
2359                          "Latest error condition(should be 0)",
2360                            coex_dm->error_condition);
2361
2362                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2363                          "\r\n %-35s = %d ", "IgnWlanAct",
2364                          coex_dm->cur_ignore_wlan_act);
2365         }
2366
2367         /* Hw setting */
2368         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2369                  "\r\n %-35s", "============[Hw setting]============");
2370
2371         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2372                  "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2373                  "backup ARFR1/ARFR2/RL/AMaxTime",
2374                  coex_dm->backup_arfr_cnt1,
2375                  coex_dm->backup_arfr_cnt2,
2376                  coex_dm->backup_retry_limit,
2377                  coex_dm->backup_ampdu_max_time);
2378
2379         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x430);
2380         u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x434);
2381         u2_tmp[0] = btcoexist->btc_read_2byte(btcoexist, 0x42a);
2382         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x456);
2383         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2384                  "\r\n %-35s = 0x%x/0x%x/0x%x/0x%x",
2385                  "0x430/0x434/0x42a/0x456",
2386                  u4_tmp[0], u4_tmp[1], u2_tmp[0], u1_tmp[0]);
2387
2388         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
2389         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc58);
2390         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2391                  "\r\n %-35s = 0x%x/ 0x%x", "0x778/ 0xc58[29:25]",
2392                  u1_tmp[0], (u4_tmp[0] & 0x3e000000) >> 25);
2393
2394         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
2395         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2396                  "\r\n %-35s = 0x%x", "0x8db[6:5]",
2397                  ((u1_tmp[0] & 0x60) >> 5));
2398
2399         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x975);
2400         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
2401         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2402                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2403                  "0xcb4[29:28]/0xcb4[7:0]/0x974[9:8]",
2404                  (u4_tmp[0] & 0x30000000) >> 28,
2405                   u4_tmp[0] & 0xff,
2406                   u1_tmp[0] & 0x3);
2407
2408         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
2409         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
2410         u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x64);
2411         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2412                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
2413                  "0x40/0x4c[24:23]/0x64[0]",
2414                  u1_tmp[0], ((u4_tmp[0] & 0x01800000) >> 23), u1_tmp[1] & 0x1);
2415
2416         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
2417         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
2418         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2419                  "\r\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522",
2420                  u4_tmp[0], u1_tmp[0]);
2421
2422         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
2423         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2424                  "\r\n %-35s = 0x%x", "0xc50(dig)",
2425                  u4_tmp[0] & 0xff);
2426
2427         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
2428         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5d);
2429         u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
2430         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2431                  "\r\n %-35s = 0x%x/ 0x%x", "OFDM-FA/ CCK-FA",
2432                  u4_tmp[0], (u1_tmp[0] << 8) + u1_tmp[1]);
2433
2434         u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
2435         u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
2436         u4_tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
2437         u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
2438         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2439                  "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
2440                  "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
2441                    u4_tmp[0], u4_tmp[1], u4_tmp[2], u1_tmp[0]);
2442
2443         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2444                  "\r\n %-35s = %d/ %d", "0x770(high-pri rx/tx)",
2445                  coex_sta->high_priority_rx, coex_sta->high_priority_tx);
2446         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2447                  "\r\n %-35s = %d/ %d", "0x774(low-pri rx/tx)",
2448                  coex_sta->low_priority_rx, coex_sta->low_priority_tx);
2449         if (btcoexist->auto_report_1ant)
2450                 btc8821a1ant_monitor_bt_ctr(btcoexist);
2451         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
2452 }
2453
2454 void ex_btc8821a1ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
2455 {
2456         struct rtl_priv *rtlpriv = btcoexist->adapter;
2457         bool wifi_under_5g = false;
2458
2459         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2460                 return;
2461         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2462         if (wifi_under_5g) {
2463                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2464                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2465                 btc8821a1ant_coex_under_5g(btcoexist);
2466                 return;
2467         }
2468
2469         if (BTC_IPS_ENTER == type) {
2470                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2471                          "[BTCoex], IPS ENTER notify\n");
2472                 coex_sta->under_ips = true;
2473                 btc8821a1ant_set_ant_path(btcoexist,
2474                                           BTC_ANT_PATH_BT, false, true);
2475                 /* set PTA control */
2476                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2477                 btc8821a1ant_coex_table_with_type(btcoexist,
2478                                                   NORMAL_EXEC, 0);
2479         } else if (BTC_IPS_LEAVE == type) {
2480                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2481                          "[BTCoex], IPS LEAVE notify\n");
2482                 coex_sta->under_ips = false;
2483
2484                 btc8821a1ant_init_hw_config(btcoexist, false, false);
2485                 btc8821a1ant_init_coex_dm(btcoexist);
2486                 btc8821a1ant_query_bt_info(btcoexist);
2487         }
2488 }
2489
2490 void ex_btc8821a1ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
2491 {
2492         struct rtl_priv *rtlpriv = btcoexist->adapter;
2493
2494         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2495                 return;
2496
2497         if (BTC_LPS_ENABLE == type) {
2498                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2499                          "[BTCoex], LPS ENABLE notify\n");
2500                 coex_sta->under_lps = true;
2501         } else if (BTC_LPS_DISABLE == type) {
2502                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2503                          "[BTCoex], LPS DISABLE notify\n");
2504                 coex_sta->under_lps = false;
2505         }
2506 }
2507
2508 void ex_btc8821a1ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
2509 {
2510         struct rtl_priv *rtlpriv = btcoexist->adapter;
2511         bool wifi_connected = false, bt_hs_on = false;
2512         bool bt_ctrl_agg_buf_size = false;
2513         bool wifi_under_5g = false;
2514         u32 wifi_link_status = 0;
2515         u32 num_of_wifi_link = 0;
2516         u8 agg_buf_size = 5;
2517
2518         if (btcoexist->manual_control || btcoexist->stop_coex_dm)
2519                 return;
2520         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2521         if (wifi_under_5g) {
2522                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2523                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2524                 btc8821a1ant_coex_under_5g(btcoexist);
2525                 return;
2526         }
2527
2528         if (type == BTC_SCAN_START) {
2529                 coex_sta->wifi_is_high_pri_task = true;
2530                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2531                          "[BTCoex], SCAN START notify\n");
2532
2533                 /* Force antenna setup for no scan result issue */
2534                 btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 8);
2535         } else {
2536                 coex_sta->wifi_is_high_pri_task = false;
2537                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2538                          "[BTCoex], SCAN FINISH notify\n");
2539         }
2540
2541         if (coex_sta->bt_disabled)
2542                 return;
2543
2544         btcoexist->btc_get(btcoexist,
2545                  BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2546         btcoexist->btc_get(btcoexist,
2547                  BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2548
2549         btc8821a1ant_query_bt_info(btcoexist);
2550
2551         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2552                            &wifi_link_status);
2553         num_of_wifi_link = wifi_link_status >> 16;
2554         if (num_of_wifi_link >= 2) {
2555                 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2556                 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2557                                         bt_ctrl_agg_buf_size, agg_buf_size);
2558                 btc8821a1ant_action_wifi_multi_port(btcoexist);
2559                 return;
2560         }
2561
2562         if (coex_sta->c2h_bt_inquiry_page) {
2563                 btc8821a1ant_action_bt_inquiry(btcoexist);
2564                 return;
2565         } else if (bt_hs_on) {
2566                 btc8821a1ant_action_hs(btcoexist);
2567                 return;
2568         }
2569
2570         if (BTC_SCAN_START == type) {
2571                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2572                          "[BTCoex], SCAN START notify\n");
2573                 if (!wifi_connected) {
2574                         /* non-connected scan */
2575                         btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2576                 } else {
2577                         /* wifi is connected */
2578                         btc8821a1ant_action_wifi_connected_scan(btcoexist);
2579                 }
2580         } else if (BTC_SCAN_FINISH == type) {
2581                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2582                          "[BTCoex], SCAN FINISH notify\n");
2583                 if (!wifi_connected) {
2584                         /* non-connected scan */
2585                         btc8821a1ant_action_wifi_not_connected(btcoexist);
2586                 } else {
2587                         btc8821a1ant_action_wifi_connected(btcoexist);
2588                 }
2589         }
2590 }
2591
2592 void ex_btc8821a1ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
2593 {
2594         struct rtl_priv *rtlpriv = btcoexist->adapter;
2595         bool wifi_connected = false, bt_hs_on = false;
2596         u32 wifi_link_status = 0;
2597         u32 num_of_wifi_link = 0;
2598         bool bt_ctrl_agg_buf_size = false;
2599         bool wifi_under_5g = false;
2600         u8 agg_buf_size = 5;
2601
2602         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2603             coex_sta->bt_disabled)
2604                 return;
2605         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2606         if (wifi_under_5g) {
2607                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2608                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2609                 btc8821a1ant_coex_under_5g(btcoexist);
2610                 return;
2611         }
2612
2613         if (type == BTC_ASSOCIATE_START) {
2614                 coex_sta->wifi_is_high_pri_task = true;
2615                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2616                          "[BTCoex], CONNECT START notify\n");
2617                 coex_dm->arp_cnt = 0;
2618         } else {
2619                 coex_sta->wifi_is_high_pri_task = false;
2620                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2621                          "[BTCoex], CONNECT FINISH notify\n");
2622                 coex_dm->arp_cnt = 0;
2623         }
2624
2625         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2626                            &wifi_link_status);
2627         num_of_wifi_link = wifi_link_status >> 16;
2628         if (num_of_wifi_link >= 2) {
2629                 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2630                 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2631                                         bt_ctrl_agg_buf_size, agg_buf_size);
2632                 btc8821a1ant_action_wifi_multi_port(btcoexist);
2633                 return;
2634         }
2635
2636         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2637         if (coex_sta->c2h_bt_inquiry_page) {
2638                 btc8821a1ant_action_bt_inquiry(btcoexist);
2639                 return;
2640         } else if (bt_hs_on) {
2641                 btc8821a1ant_action_hs(btcoexist);
2642                 return;
2643         }
2644
2645         if (BTC_ASSOCIATE_START == type) {
2646                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2647                          "[BTCoex], CONNECT START notify\n");
2648                 btc8821a1ant_act_wifi_not_conn_scan(btcoexist);
2649         } else if (BTC_ASSOCIATE_FINISH == type) {
2650                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2651                          "[BTCoex], CONNECT FINISH notify\n");
2652
2653                 btcoexist->btc_get(btcoexist,
2654                          BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2655                 if (!wifi_connected) {
2656                         /* non-connected scan */
2657                         btc8821a1ant_action_wifi_not_connected(btcoexist);
2658                 } else {
2659                         btc8821a1ant_action_wifi_connected(btcoexist);
2660                 }
2661         }
2662 }
2663
2664 void ex_btc8821a1ant_media_status_notify(struct btc_coexist *btcoexist,
2665                                          u8 type)
2666 {
2667         struct rtl_priv *rtlpriv = btcoexist->adapter;
2668         u8 h2c_parameter[3] = {0};
2669         u32 wifi_bw;
2670         u8 wifi_central_chnl;
2671         bool wifi_under_5g = false;
2672
2673         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2674             coex_sta->bt_disabled)
2675                 return;
2676         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2677         if (wifi_under_5g) {
2678                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2679                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2680                 btc8821a1ant_coex_under_5g(btcoexist);
2681                 return;
2682         }
2683
2684         if (BTC_MEDIA_CONNECT == type) {
2685                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2686                          "[BTCoex], MEDIA connect notify\n");
2687         } else {
2688                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2689                          "[BTCoex], MEDIA disconnect notify\n");
2690                 coex_dm->arp_cnt = 0;
2691         }
2692
2693         /* only 2.4G we need to inform bt the chnl mask */
2694         btcoexist->btc_get(btcoexist,
2695                            BTC_GET_U1_WIFI_CENTRAL_CHNL,
2696                            &wifi_central_chnl);
2697         if ((type == BTC_MEDIA_CONNECT) &&
2698             (wifi_central_chnl <= 14)) {
2699                 h2c_parameter[0] = 0x0;
2700                 h2c_parameter[1] = wifi_central_chnl;
2701                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2702                 if (wifi_bw == BTC_WIFI_BW_HT40)
2703                         h2c_parameter[2] = 0x30;
2704                 else
2705                         h2c_parameter[2] = 0x20;
2706         }
2707
2708         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
2709         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
2710         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
2711
2712         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2713                  "[BTCoex], FW write 0x66 = 0x%x\n",
2714                  h2c_parameter[0] << 16 |
2715                  h2c_parameter[1] << 8 |
2716                  h2c_parameter[2]);
2717
2718         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
2719 }
2720
2721 void ex_btc8821a1ant_special_packet_notify(struct btc_coexist *btcoexist,
2722                                            u8 type)
2723 {
2724         struct rtl_priv *rtlpriv = btcoexist->adapter;
2725         bool bt_hs_on = false;
2726         bool bt_ctrl_agg_buf_size = false;
2727         bool wifi_under_5g = false;
2728         u32 wifi_link_status = 0;
2729         u32 num_of_wifi_link = 0;
2730         u8 agg_buf_size = 5;
2731
2732         if (btcoexist->manual_control || btcoexist->stop_coex_dm ||
2733             coex_sta->bt_disabled)
2734                 return;
2735
2736         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2737         if (wifi_under_5g) {
2738                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2739                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2740                 btc8821a1ant_coex_under_5g(btcoexist);
2741                 return;
2742         }
2743
2744         if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2745             type == BTC_PACKET_ARP) {
2746                 coex_sta->wifi_is_high_pri_task = true;
2747
2748                 if (type == BTC_PACKET_ARP) {
2749                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2750                                  "[BTCoex], specific Packet ARP notify\n");
2751                 } else {
2752                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2753                                  "[BTCoex], specific Packet DHCP or EAPOL notify\n");
2754                 }
2755         } else {
2756                 coex_sta->wifi_is_high_pri_task = false;
2757                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2758                          "[BTCoex], specific Packet [Type = %d] notify\n",
2759                          type);
2760         }
2761
2762         coex_sta->special_pkt_period_cnt = 0;
2763
2764         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_LINK_STATUS,
2765                            &wifi_link_status);
2766         num_of_wifi_link = wifi_link_status >> 16;
2767         if (num_of_wifi_link >= 2) {
2768                 btc8821a1ant_limited_tx(btcoexist, NORMAL_EXEC, 0, 0, 0, 0);
2769                 btc8821a1ant_limited_rx(btcoexist, NORMAL_EXEC, false,
2770                                         bt_ctrl_agg_buf_size, agg_buf_size);
2771                 btc8821a1ant_action_wifi_multi_port(btcoexist);
2772                 return;
2773         }
2774
2775         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
2776         if (coex_sta->c2h_bt_inquiry_page) {
2777                 btc8821a1ant_action_bt_inquiry(btcoexist);
2778                 return;
2779         } else if (bt_hs_on) {
2780                 btc8821a1ant_action_hs(btcoexist);
2781                 return;
2782         }
2783
2784         if (type == BTC_PACKET_DHCP || type == BTC_PACKET_EAPOL ||
2785             type == BTC_PACKET_ARP) {
2786                 if (type == BTC_PACKET_ARP) {
2787                         coex_dm->arp_cnt++;
2788                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2789                                  "[BTCoex], ARP Packet Count = %d\n",
2790                                  coex_dm->arp_cnt);
2791                         if (coex_dm->arp_cnt >= 10)
2792                                 /* if APR PKT > 10 after connect, do not go to
2793                                  * btc8821a1ant_act_wifi_conn_sp_pkt
2794                                  */
2795                                 return;
2796                 }
2797
2798                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2799                          "[BTCoex], special Packet(%d) notify\n", type);
2800                 btc8821a1ant_act_wifi_conn_sp_pkt(btcoexist);
2801         }
2802 }
2803
2804 void ex_btc8821a1ant_bt_info_notify(struct btc_coexist *btcoexist,
2805                                     u8 *tmp_buf, u8 length)
2806 {
2807         struct rtl_priv *rtlpriv = btcoexist->adapter;
2808         u8 i;
2809         u8 bt_info = 0;
2810         u8 rsp_source = 0;
2811         bool wifi_connected = false;
2812         bool bt_busy = false;
2813         bool wifi_under_5g = false;
2814
2815         coex_sta->c2h_bt_info_req_sent = false;
2816
2817         btcoexist->btc_get(btcoexist,
2818                  BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2819
2820         rsp_source = tmp_buf[0] & 0xf;
2821         if (rsp_source >= BT_INFO_SRC_8821A_1ANT_MAX)
2822                 rsp_source = BT_INFO_SRC_8821A_1ANT_WIFI_FW;
2823         coex_sta->bt_info_c2h_cnt[rsp_source]++;
2824
2825         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2826                  "[BTCoex], Bt info[%d], length = %d, hex data = [",
2827                  rsp_source, length);
2828         for (i = 0; i < length; i++) {
2829                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
2830                 if (i == 1)
2831                         bt_info = tmp_buf[i];
2832                 if (i == length - 1) {
2833                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2834                                  "0x%02x]\n", tmp_buf[i]);
2835                 } else {
2836                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2837                                  "0x%02x, ", tmp_buf[i]);
2838                 }
2839         }
2840
2841         if (BT_INFO_SRC_8821A_1ANT_WIFI_FW != rsp_source) {
2842                 /* [3:0] */
2843                 coex_sta->bt_retry_cnt =
2844                         coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
2845
2846                 coex_sta->bt_rssi =
2847                         coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
2848
2849                 coex_sta->bt_info_ext = coex_sta->bt_info_c2h[rsp_source][4];
2850
2851                 coex_sta->bt_tx_rx_mask =
2852                         (coex_sta->bt_info_c2h[rsp_source][2] & 0x40);
2853                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TX_RX_MASK,
2854                                    &coex_sta->bt_tx_rx_mask);
2855                 if (!coex_sta->bt_tx_rx_mask) {
2856                         /* BT into is responded by BT FW and BT RF REG 0x3C !=
2857                          * 0x15 => Need to switch BT TRx Mask
2858                          */
2859                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2860                                  "[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x15\n");
2861                         btcoexist->btc_set_bt_reg(btcoexist, BTC_BT_REG_RF,
2862                                                   0x3c, 0x15);
2863                 }
2864
2865                 /* Here we need to resend some wifi info to BT
2866                  * because bt is reset and lost the info
2867                  */
2868                 if (coex_sta->bt_info_ext & BIT1) {
2869                         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2870                                  "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
2871                         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
2872                                            &wifi_connected);
2873                         if (wifi_connected) {
2874                                 ex_btc8821a1ant_media_status_notify(btcoexist,
2875                                                                BTC_MEDIA_CONNECT);
2876                         } else {
2877                                 ex_btc8821a1ant_media_status_notify(btcoexist,
2878                                                                BTC_MEDIA_DISCONNECT);
2879                         }
2880                 }
2881
2882                 if ((coex_sta->bt_info_ext & BIT3) && !wifi_under_5g) {
2883                         if (!btcoexist->manual_control &&
2884                             !btcoexist->stop_coex_dm) {
2885                                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2886                                          "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
2887                                 btc8821a1ant_ignore_wlan_act(btcoexist,
2888                                                              FORCE_EXEC,
2889                                                              false);
2890                         }
2891                 }
2892         }
2893
2894         /* check BIT2 first ==> check if bt is under inquiry or page scan */
2895         if (bt_info & BT_INFO_8821A_1ANT_B_INQ_PAGE)
2896                 coex_sta->c2h_bt_inquiry_page = true;
2897         else
2898                 coex_sta->c2h_bt_inquiry_page = false;
2899
2900         /* set link exist status */
2901         if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2902                 coex_sta->bt_link_exist = false;
2903                 coex_sta->pan_exist = false;
2904                 coex_sta->a2dp_exist = false;
2905                 coex_sta->hid_exist = false;
2906                 coex_sta->sco_exist = false;
2907         } else {
2908                 /* connection exists */
2909                 coex_sta->bt_link_exist = true;
2910                 if (bt_info & BT_INFO_8821A_1ANT_B_FTP)
2911                         coex_sta->pan_exist = true;
2912                 else
2913                         coex_sta->pan_exist = false;
2914                 if (bt_info & BT_INFO_8821A_1ANT_B_A2DP)
2915                         coex_sta->a2dp_exist = true;
2916                 else
2917                         coex_sta->a2dp_exist = false;
2918                 if (bt_info & BT_INFO_8821A_1ANT_B_HID)
2919                         coex_sta->hid_exist = true;
2920                 else
2921                         coex_sta->hid_exist = false;
2922                 if (bt_info & BT_INFO_8821A_1ANT_B_SCO_ESCO)
2923                         coex_sta->sco_exist = true;
2924                 else
2925                         coex_sta->sco_exist = false;
2926         }
2927
2928         btc8821a1ant_update_bt_link_info(btcoexist);
2929
2930         /* mask profile bit for connect-ilde identification
2931          * (for CSR case: A2DP idle --> 0x41)
2932          */
2933         bt_info = bt_info & 0x1f;
2934
2935         if (!(bt_info & BT_INFO_8821A_1ANT_B_CONNECTION)) {
2936                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
2937                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2938                          "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
2939         } else if (bt_info == BT_INFO_8821A_1ANT_B_CONNECTION) {
2940                 /* connection exists but no busy */
2941                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_CONNECTED_IDLE;
2942                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2943                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
2944         } else if ((bt_info&BT_INFO_8821A_1ANT_B_SCO_ESCO) ||
2945                 (bt_info & BT_INFO_8821A_1ANT_B_SCO_BUSY)) {
2946                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_SCO_BUSY;
2947                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2948                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
2949         } else if (bt_info & BT_INFO_8821A_1ANT_B_ACL_BUSY) {
2950                 if (BT_8821A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status)
2951                         coex_dm->auto_tdma_adjust = false;
2952                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_ACL_BUSY;
2953                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2954                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
2955         } else {
2956                 coex_dm->bt_status = BT_8821A_1ANT_BT_STATUS_MAX;
2957                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2958                          "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
2959         }
2960
2961         if ((BT_8821A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
2962             (BT_8821A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
2963             (BT_8821A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status))
2964                 bt_busy = true;
2965         else
2966                 bt_busy = false;
2967         btcoexist->btc_set(btcoexist,
2968                            BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
2969
2970         btc8821a1ant_run_coexist_mechanism(btcoexist);
2971 }
2972
2973 void ex_btc8821a1ant_halt_notify(struct btc_coexist *btcoexist)
2974 {
2975         struct rtl_priv *rtlpriv = btcoexist->adapter;
2976         bool wifi_under_5g = false;
2977
2978         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2979                  "[BTCoex], Halt notify\n");
2980         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
2981         if (wifi_under_5g) {
2982                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
2983                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
2984                 btc8821a1ant_coex_under_5g(btcoexist);
2985                 return;
2986         }
2987
2988
2989         btcoexist->stop_coex_dm = true;
2990
2991         btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false, true);
2992         btc8821a1ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
2993
2994         btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2995         btc8821a1ant_ps_tdma(btcoexist, FORCE_EXEC, false, 0);
2996
2997         ex_btc8821a1ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
2998 }
2999
3000 void ex_btc8821a1ant_pnp_notify(struct btc_coexist *btcoexist, u8 pnp_state)
3001 {
3002         struct rtl_priv *rtlpriv = btcoexist->adapter;
3003         bool wifi_under_5g = false;
3004
3005         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3006         if (wifi_under_5g) {
3007                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3008                          "[BTCoex], RunCoexistMechanism(), return for 5G <===\n");
3009                 btc8821a1ant_coex_under_5g(btcoexist);
3010                 return;
3011         }
3012
3013         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3014                  "[BTCoex], Pnp notify\n");
3015
3016         if (BTC_WIFI_PNP_SLEEP == pnp_state) {
3017                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3018                          "[BTCoex], Pnp notify to SLEEP\n");
3019                 /* BT should clear UnderIPS/UnderLPS state to avoid mismatch
3020                  * state after wakeup.
3021                  */
3022                 coex_sta->under_ips = false;
3023                 coex_sta->under_lps = false;
3024                 btcoexist->stop_coex_dm = true;
3025                 btc8821a1ant_power_save_state(btcoexist, BTC_PS_WIFI_NATIVE,
3026                                               0x0, 0x0);
3027                 btc8821a1ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
3028                 btc8821a1ant_coex_table_with_type(btcoexist, NORMAL_EXEC, 2);
3029                 btc8821a1ant_set_ant_path(btcoexist, BTC_ANT_PATH_BT, false,
3030                                           true);
3031         } else if (BTC_WIFI_PNP_WAKE_UP == pnp_state) {
3032                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3033                          "[BTCoex], Pnp notify to WAKE UP\n");
3034                 btcoexist->stop_coex_dm = false;
3035                 btc8821a1ant_init_hw_config(btcoexist, false, false);
3036                 btc8821a1ant_init_coex_dm(btcoexist);
3037                 btc8821a1ant_query_bt_info(btcoexist);
3038         }
3039 }
3040
3041 void ex_btc8821a1ant_periodical(struct btc_coexist *btcoexist)
3042 {
3043         struct rtl_priv *rtlpriv = btcoexist->adapter;
3044         static u8 dis_ver_info_cnt;
3045         u32 fw_ver = 0, bt_patch_ver = 0;
3046         struct btc_board_info *board_info = &btcoexist->board_info;
3047         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3048
3049         RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3050                  "[BTCoex], ==========================Periodical===========================\n");
3051
3052         if (dis_ver_info_cnt <= 5) {
3053                 dis_ver_info_cnt += 1;
3054                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3055                          "[BTCoex], ****************************************************************\n");
3056                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3057                          "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
3058                               board_info->pg_ant_num,
3059                               board_info->btdm_ant_num,
3060                               board_info->btdm_ant_pos);
3061                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3062                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3063                               stack_info->profile_notified ? "Yes" : "No",
3064                               stack_info->hci_version);
3065                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3066                                    &bt_patch_ver);
3067                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3068                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3069                          "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3070                               glcoex_ver_date_8821a_1ant,
3071                               glcoex_ver_8821a_1ant,
3072                               fw_ver, bt_patch_ver,
3073                               bt_patch_ver);
3074                 RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
3075                          "[BTCoex], ****************************************************************\n");
3076         }
3077
3078         if (!btcoexist->auto_report_1ant) {
3079                 btc8821a1ant_query_bt_info(btcoexist);
3080                 btc8821a1ant_monitor_bt_ctr(btcoexist);
3081         } else {
3082                 coex_sta->special_pkt_period_cnt++;
3083         }
3084 }