drivers/staging/rtl8192ee/btcoexist/halbtc8821a1ant.c

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