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

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2012  Realtek Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * The full GNU General Public License is included in this distribution in the
  15  * file called LICENSE.
  16  *
  17  * Contact Information:
  18  * wlanfae <wlanfae@realtek.com>
  19  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  20  * Hsinchu 300, Taiwan.
  21  *
  22  * Larry Finger <Larry.Finger@lwfinger.net>
  23  *
  24  *****************************************************************************/
  25
  26 /*============================================================
  27  * Description:
  28  *
  29  * This file is for RTL8821A Co-exist mechanism
  30  *
  31  * History
  32  * 2012/08/22 Cosa first check in.
  33  * 2012/11/14 Cosa Revise for 8821A 2Ant out sourcing.
  34  *
  35  *============================================================
  36  */
  37
  38 /*============================================================
  39  * include files
  40  *============================================================
  41 */
  42 #include "halbt_precomp.h"
  43 /*============================================================
  44  * Global variables, these are static variables
  45  *============================================================
  46  */
  47 static struct coex_dm_8821a_2ant        glcoex_dm_8821a_2ant;
  48 static struct coex_dm_8821a_2ant        *coex_dm = &glcoex_dm_8821a_2ant;
  49 static struct coex_sta_8821a_2ant       glcoex_sta_8821a_2ant;
  50 static struct coex_sta_8821a_2ant       *coex_sta = &glcoex_sta_8821a_2ant;
  51
  52 static const char *const glbt_info_src_8821a_2ant[] = {
  53         "BT Info[wifi fw]",
  54         "BT Info[bt rsp]",
  55         "BT Info[bt auto report]",
  56 };
  57
  58 static u32      glcoex_ver_date_8821a_2ant = 20130618;
  59 static u32      glcoex_ver_8821a_2ant = 0x5050;
  60
  61 /*============================================================
  62  * local function proto type if needed
  63  *============================================================
  64  *============================================================
  65  * local function start with halbtc8821a2ant_
  66  *============================================================
  67  */
  68 static u8 halbtc8821a2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
  69                                         u8 rssi_thresh1)
  70 {
  71         long    bt_rssi = 0;
  72         u8      bt_rssi_state = coex_sta->pre_bt_rssi_state;
  73
  74         bt_rssi = coex_sta->bt_rssi;
  75
  76         if (level_num == 2) {
  77                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  78                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  79                         long tmp = rssi_thresh +
  80                                    BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT;
  81                         if (bt_rssi >= tmp) {
  82                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
  83                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  84                                             "[BTCoex], BT Rssi state switch to High\n");
  85                         } else {
  86                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  87                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  88                                             "[BTCoex], BT Rssi state stay at Low\n");
  89                         }
  90                 } else {
  91                         if (bt_rssi < rssi_thresh) {
  92                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
  93                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  94                                             "[BTCoex], BT Rssi state switch to Low\n");
  95                         } else {
  96                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  97                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
  98                                             "[BTCoex], BT Rssi state stay at High\n");
  99                         }
 100                 }
 101         } else if (level_num == 3) {
 102                 if (rssi_thresh > rssi_thresh1) {
 103                         btc_alg_dbg(ALGO_BT_RSSI_STATE,
 104                                     "[BTCoex], BT Rssi thresh error!!\n");
 105                         return coex_sta->pre_bt_rssi_state;
 106                 }
 107
 108                 if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
 109                     (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 110                         if (bt_rssi >=
 111                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
 112                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 113                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 114                                             "[BTCoex], BT Rssi state switch to Medium\n");
 115                         } else {
 116                                 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 117                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 118                                             "[BTCoex], BT Rssi state stay at Low\n");
 119                         }
 120                 } else if ((coex_sta->pre_bt_rssi_state ==
 121                            BTC_RSSI_STATE_MEDIUM) ||
 122                            (coex_sta->pre_bt_rssi_state ==
 123                             BTC_RSSI_STATE_STAY_MEDIUM)) {
 124                         if (bt_rssi >=
 125                             (rssi_thresh1 +
 126                              BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
 127                                 bt_rssi_state = BTC_RSSI_STATE_HIGH;
 128                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 129                                             "[BTCoex], BT Rssi state switch to High\n");
 130                         } else if (bt_rssi < rssi_thresh) {
 131                                 bt_rssi_state = BTC_RSSI_STATE_LOW;
 132                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 133                                             "[BTCoex], BT Rssi state switch to Low\n");
 134                         } else {
 135                                 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 136                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 137                                             "[BTCoex], BT Rssi state stay at Medium\n");
 138                         }
 139                 } else {
 140                         if (bt_rssi < rssi_thresh1) {
 141                                 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 142                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 143                                             "[BTCoex], BT Rssi state switch to Medium\n");
 144                         } else {
 145                                 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 146                                 btc_alg_dbg(ALGO_BT_RSSI_STATE,
 147                                             "[BTCoex], BT Rssi state stay at High\n");
 148                         }
 149                 }
 150         }
 151
 152         coex_sta->pre_bt_rssi_state = bt_rssi_state;
 153
 154         return bt_rssi_state;
 155 }
 156
 157 static u8 halbtc8821a2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
 158                                           u8 index, u8 level_num,
 159                                           u8 rssi_thresh, u8 rssi_thresh1)
 160 {
 161         long    wifi_rssi = 0;
 162         u8      wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
 163
 164         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 165
 166         if (level_num == 2) {
 167                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 168                      BTC_RSSI_STATE_LOW) ||
 169                     (coex_sta->pre_wifi_rssi_state[index] ==
 170                      BTC_RSSI_STATE_STAY_LOW)) {
 171                         if (wifi_rssi >=
 172                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
 173                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 174                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 175                                             "[BTCoex], wifi RSSI state switch to High\n");
 176                         } else {
 177                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 178                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 179                                             "[BTCoex], wifi RSSI state stay at Low\n");
 180                         }
 181                 } else {
 182                         if (wifi_rssi < rssi_thresh) {
 183                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 184                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 185                                             "[BTCoex], wifi RSSI state switch to Low\n");
 186                         } else {
 187                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 188                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 189                                             "[BTCoex], wifi RSSI state stay at High\n");
 190                         }
 191                 }
 192         } else if (level_num == 3) {
 193                 if (rssi_thresh > rssi_thresh1) {
 194                         btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 195                                     "[BTCoex], wifi RSSI thresh error!!\n");
 196                         return coex_sta->pre_wifi_rssi_state[index];
 197                 }
 198
 199                 if ((coex_sta->pre_wifi_rssi_state[index] ==
 200                     BTC_RSSI_STATE_LOW) ||
 201                     (coex_sta->pre_wifi_rssi_state[index] ==
 202                      BTC_RSSI_STATE_STAY_LOW)) {
 203                         if (wifi_rssi >=
 204                             (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
 205                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 206                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 207                                             "[BTCoex], wifi RSSI state switch to Medium\n");
 208                         } else {
 209                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 210                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 211                                             "[BTCoex], wifi RSSI state stay at Low\n");
 212                         }
 213                 } else if ((coex_sta->pre_wifi_rssi_state[index] ==
 214                            BTC_RSSI_STATE_MEDIUM) ||
 215                            (coex_sta->pre_wifi_rssi_state[index] ==
 216                             BTC_RSSI_STATE_STAY_MEDIUM)) {
 217                         if (wifi_rssi >= (rssi_thresh1 +
 218                             BTC_RSSI_COEX_THRESH_TOL_8821A_2ANT)) {
 219                                 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 220                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 221                                             "[BTCoex], wifi RSSI state switch to High\n");
 222                         } else if (wifi_rssi < rssi_thresh) {
 223                                 wifi_rssi_state = BTC_RSSI_STATE_LOW;
 224                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 225                                             "[BTCoex], wifi RSSI state switch to Low\n");
 226                         } else {
 227                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 228                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 229                                             "[BTCoex], wifi RSSI state stay at Medium\n");
 230                         }
 231                 } else {
 232                         if (wifi_rssi < rssi_thresh1) {
 233                                 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 234                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 235                                             "[BTCoex], wifi RSSI state switch to Medium\n");
 236                         } else {
 237                                 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 238                                 btc_alg_dbg(ALGO_WIFI_RSSI_STATE,
 239                                             "[BTCoex], wifi RSSI state stay at High\n");
 240                         }
 241                 }
 242         }
 243         coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
 244
 245         return wifi_rssi_state;
 246 }
 247
 248 static void btc8821a2ant_mon_bt_en_dis(struct btc_coexist *btcoexist)
 249 {
 250         static bool     pre_bt_disabled;
 251         static u32      bt_disable_cnt;
 252         bool            bt_active = true, bt_disabled = false;
 253
 254         /* This function check if bt is disabled*/
 255
 256         if (coex_sta->high_priority_tx == 0 &&
 257             coex_sta->high_priority_rx == 0 &&
 258             coex_sta->low_priority_tx == 0 &&
 259             coex_sta->low_priority_rx == 0)
 260                 bt_active = false;
 261         if (coex_sta->high_priority_tx == 0xffff &&
 262             coex_sta->high_priority_rx == 0xffff &&
 263             coex_sta->low_priority_tx == 0xffff &&
 264             coex_sta->low_priority_rx == 0xffff)
 265                 bt_active = false;
 266         if (bt_active) {
 267                 bt_disable_cnt = 0;
 268                 bt_disabled = false;
 269                 btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
 270                                    &bt_disabled);
 271                 btc_alg_dbg(ALGO_BT_MONITOR,
 272                             "[BTCoex], BT is enabled !!\n");
 273         } else {
 274                 bt_disable_cnt++;
 275                 btc_alg_dbg(ALGO_BT_MONITOR,
 276                             "[BTCoex], bt all counters = 0, %d times!!\n",
 277                             bt_disable_cnt);
 278                 if (bt_disable_cnt >= 2) {
 279                         bt_disabled = true;
 280                         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE,
 281                                            &bt_disabled);
 282                         btc_alg_dbg(ALGO_BT_MONITOR,
 283                                     "[BTCoex], BT is disabled !!\n");
 284                 }
 285         }
 286         if (pre_bt_disabled != bt_disabled) {
 287                 btc_alg_dbg(ALGO_BT_MONITOR,
 288                             "[BTCoex], BT is from %s to %s!!\n",
 289                             (pre_bt_disabled ? "disabled" : "enabled"),
 290                             (bt_disabled ? "disabled" : "enabled"));
 291                 pre_bt_disabled = bt_disabled;
 292         }
 293 }
 294
 295 static void halbtc8821a2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 296 {
 297         u32     reg_hp_txrx, reg_lp_txrx, u4tmp;
 298         u32     reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
 299
 300         reg_hp_txrx = 0x770;
 301         reg_lp_txrx = 0x774;
 302
 303         u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 304         reg_hp_tx = u4tmp & MASKLWORD;
 305         reg_hp_rx = (u4tmp & MASKHWORD)>>16;
 306
 307         u4tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 308         reg_lp_tx = u4tmp & MASKLWORD;
 309         reg_lp_rx = (u4tmp & MASKHWORD)>>16;
 310
 311         coex_sta->high_priority_tx = reg_hp_tx;
 312         coex_sta->high_priority_rx = reg_hp_rx;
 313         coex_sta->low_priority_tx = reg_lp_tx;
 314         coex_sta->low_priority_rx = reg_lp_rx;
 315
 316         btc_alg_dbg(ALGO_BT_MONITOR,
 317                     "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 318                     reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
 319         btc_alg_dbg(ALGO_BT_MONITOR,
 320                     "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 321                     reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 322
 323         /* reset counter */
 324         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 325 }
 326
 327 static void halbtc8821a2ant_query_bt_info(struct btc_coexist *btcoexist)
 328 {
 329         u8      h2c_parameter[1] = {0};
 330
 331         coex_sta->c2h_bt_info_req_sent = true;
 332
 333         h2c_parameter[0] |= BIT0;       /* trigger */
 334
 335         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 336                     "[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n",
 337                     h2c_parameter[0]);
 338
 339         btcoexist->btc_fill_h2c(btcoexist, 0x61, 1, h2c_parameter);
 340 }
 341
 342 static u8 halbtc8821a2ant_action_algorithm(struct btc_coexist *btcoexist)
 343 {
 344         struct btc_stack_info *stack_info = &btcoexist->stack_info;
 345         bool bt_hs_on = false;
 346         u8 algorithm = BT_8821A_2ANT_COEX_ALGO_UNDEFINED;
 347         u8 num_of_diff_profile = 0;
 348
 349         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 350
 351         /*for win-8 stack HID report error*/
 352         /* sync  BTInfo with BT firmware and stack */
 353         if (!stack_info->hid_exist)
 354                 stack_info->hid_exist = coex_sta->hid_exist;
 355         /* when stack HID report error, here we use the info from bt fw. */
 356         if (!stack_info->bt_link_exist)
 357                 stack_info->bt_link_exist = coex_sta->bt_link_exist;
 358
 359         if (!coex_sta->bt_link_exist) {
 360                 btc_alg_dbg(ALGO_TRACE,
 361                             "[BTCoex], No profile exists!!!\n");
 362                 return algorithm;
 363         }
 364
 365         if (coex_sta->sco_exist)
 366                 num_of_diff_profile++;
 367         if (coex_sta->hid_exist)
 368                 num_of_diff_profile++;
 369         if (coex_sta->pan_exist)
 370                 num_of_diff_profile++;
 371         if (coex_sta->a2dp_exist)
 372                 num_of_diff_profile++;
 373
 374         if (num_of_diff_profile == 1) {
 375                 if (coex_sta->sco_exist) {
 376                         btc_alg_dbg(ALGO_TRACE,
 377                                     "[BTCoex], SCO only\n");
 378                         algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
 379                 } else {
 380                         if (coex_sta->hid_exist) {
 381                                 btc_alg_dbg(ALGO_TRACE,
 382                                             "[BTCoex], HID only\n");
 383                                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID;
 384                         } else if (coex_sta->a2dp_exist) {
 385                                 btc_alg_dbg(ALGO_TRACE,
 386                                             "[BTCoex], A2DP only\n");
 387                                 algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP;
 388                         } else if (coex_sta->pan_exist) {
 389                                 if (bt_hs_on) {
 390                                         btc_alg_dbg(ALGO_TRACE,
 391                                                     "[BTCoex], PAN(HS) only\n");
 392                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANHS;
 393                                 } else {
 394                                         btc_alg_dbg(ALGO_TRACE,
 395                                                     "[BTCoex], PAN(EDR) only\n");
 396                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR;
 397                                 }
 398                         }
 399                 }
 400         } else if (num_of_diff_profile == 2) {
 401                 if (coex_sta->sco_exist) {
 402                         if (coex_sta->hid_exist) {
 403                                 btc_alg_dbg(ALGO_TRACE,
 404                                             "[BTCoex], SCO + HID\n");
 405                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 406                         } else if (coex_sta->a2dp_exist) {
 407                                 btc_alg_dbg(ALGO_TRACE,
 408                                             "[BTCoex], SCO + A2DP ==> SCO\n");
 409                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 410                         } else if (coex_sta->pan_exist) {
 411                                 if (bt_hs_on) {
 412                                         btc_alg_dbg(ALGO_TRACE,
 413                                                     "[BTCoex], SCO + PAN(HS)\n");
 414                                         algorithm = BT_8821A_2ANT_COEX_ALGO_SCO;
 415                                 } else {
 416                                         btc_alg_dbg(ALGO_TRACE,
 417                                                     "[BTCoex], SCO + PAN(EDR)\n");
 418                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 419                                 }
 420                         }
 421                 } else {
 422                         if (coex_sta->hid_exist &&
 423                             coex_sta->a2dp_exist) {
 424                                 btc_alg_dbg(ALGO_TRACE,
 425                                             "[BTCoex], HID + A2DP\n");
 426                                 algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
 427                         } else if (coex_sta->hid_exist &&
 428                                 coex_sta->pan_exist) {
 429                                 if (bt_hs_on) {
 430                                         btc_alg_dbg(ALGO_TRACE,
 431                                                     "[BTCoex], HID + PAN(HS)\n");
 432                                         algorithm =  BT_8821A_2ANT_COEX_ALGO_HID;
 433                                 } else {
 434                                         btc_alg_dbg(ALGO_TRACE,
 435                                                     "[BTCoex], HID + PAN(EDR)\n");
 436                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 437                                 }
 438                         } else if (coex_sta->pan_exist &&
 439                                 coex_sta->a2dp_exist) {
 440                                 if (bt_hs_on) {
 441                                         btc_alg_dbg(ALGO_TRACE,
 442                                                     "[BTCoex], A2DP + PAN(HS)\n");
 443                                         algorithm = BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS;
 444                                 } else {
 445                                         btc_alg_dbg(ALGO_TRACE,
 446                                                     "[BTCoex], A2DP + PAN(EDR)\n");
 447                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP;
 448                                 }
 449                         }
 450                 }
 451         } else if (num_of_diff_profile == 3) {
 452                 if (coex_sta->sco_exist) {
 453                         if (coex_sta->hid_exist &&
 454                             coex_sta->a2dp_exist) {
 455                                 btc_alg_dbg(ALGO_TRACE,
 456                                             "[BTCoex], SCO + HID + A2DP ==> HID\n");
 457                                 algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 458                         } else if (coex_sta->hid_exist &&
 459                                 coex_sta->pan_exist) {
 460                                 if (bt_hs_on) {
 461                                         btc_alg_dbg(ALGO_TRACE,
 462                                                     "[BTCoex], SCO + HID + PAN(HS)\n");
 463                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 464                                 } else {
 465                                         btc_alg_dbg(ALGO_TRACE,
 466                                                     "[BTCoex], SCO + HID + PAN(EDR)\n");
 467                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 468                                 }
 469                         } else if (coex_sta->pan_exist &&
 470                                    coex_sta->a2dp_exist) {
 471                                 if (bt_hs_on) {
 472                                         btc_alg_dbg(ALGO_TRACE,
 473                                                     "[BTCoex], SCO + A2DP + PAN(HS)\n");
 474                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 475                                 } else {
 476                                         btc_alg_dbg(ALGO_TRACE,
 477                                                     "[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n");
 478                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 479                                 }
 480                         }
 481                 } else {
 482                         if (coex_sta->hid_exist &&
 483                             coex_sta->pan_exist &&
 484                             coex_sta->a2dp_exist) {
 485                                 if (bt_hs_on) {
 486                                         btc_alg_dbg(ALGO_TRACE,
 487                                                     "[BTCoex], HID + A2DP + PAN(HS)\n");
 488                                         algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP;
 489                                 } else {
 490                                         btc_alg_dbg(ALGO_TRACE,
 491                                                     "[BTCoex], HID + A2DP + PAN(EDR)\n");
 492                                         algorithm = BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 493                                 }
 494                         }
 495                 }
 496         } else if (num_of_diff_profile >= 3) {
 497                 if (coex_sta->sco_exist) {
 498                         if (coex_sta->hid_exist &&
 499                             coex_sta->pan_exist &&
 500                             coex_sta->a2dp_exist) {
 501                                 if (bt_hs_on) {
 502                                         btc_alg_dbg(ALGO_TRACE,
 503                                                     "[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n");
 504
 505                                 } else {
 506                                         btc_alg_dbg(ALGO_TRACE,
 507                                                     "[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n");
 508                                         algorithm = BT_8821A_2ANT_COEX_ALGO_PANEDR_HID;
 509                                 }
 510                         }
 511                 }
 512         }
 513         return algorithm;
 514 }
 515
 516 static bool halbtc8821a2ant_need_to_dec_bt_pwr(struct btc_coexist *btcoexist)
 517 {
 518         bool ret = false;
 519         bool bt_hs_on = false, wifi_connected = false;
 520         long bt_hs_rssi = 0;
 521         u8 bt_rssi_state;
 522
 523         if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on))
 524                 return false;
 525         if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 526                                 &wifi_connected))
 527                 return false;
 528         if (!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi))
 529                 return false;
 530
 531         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
 532
 533         if (wifi_connected) {
 534                 if (bt_hs_on) {
 535                         if (bt_hs_rssi > 37) {
 536                                 btc_alg_dbg(ALGO_TRACE_FW,
 537                                             "[BTCoex], Need to decrease bt power for HS mode!!\n");
 538                                 ret = true;
 539                         }
 540                 } else {
 541                         if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
 542                             (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
 543                                 btc_alg_dbg(ALGO_TRACE_FW,
 544                                             "[BTCoex], Need to decrease bt power for Wifi is connected!!\n");
 545                                 ret = true;
 546                         }
 547                 }
 548         }
 549         return ret;
 550 }
 551
 552 static void btc8821a2ant_set_fw_dac_swing_lev(struct btc_coexist *btcoexist,
 553                                               u8 dac_swing_lvl)
 554 {
 555         u8      h2c_parameter[1] = {0};
 556
 557         /* There are several type of dacswing
 558          * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
 559          */
 560         h2c_parameter[0] = dac_swing_lvl;
 561
 562         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 563                     "[BTCoex], Set Dac Swing Level = 0x%x\n", dac_swing_lvl);
 564         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 565                     "[BTCoex], FW write 0x64 = 0x%x\n", h2c_parameter[0]);
 566
 567         btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 568 }
 569
 570 static void halbtc8821a2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 571                                               bool dec_bt_pwr)
 572 {
 573         u8                      h2c_parameter[1] = {0};
 574
 575         h2c_parameter[0] = 0;
 576
 577         if (dec_bt_pwr)
 578                 h2c_parameter[0] |= BIT1;
 579
 580         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 581                     "[BTCoex], decrease Bt Power : %s, FW write 0x62 = 0x%x\n",
 582                     (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
 583
 584         btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 585 }
 586
 587 static void halbtc8821a2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
 588                                        bool force_exec, bool dec_bt_pwr)
 589 {
 590         btc_alg_dbg(ALGO_TRACE_FW,
 591                     "[BTCoex], %s Dec BT power = %s\n",
 592                     (force_exec ? "force to" : ""),
 593                     ((dec_bt_pwr) ? "ON" : "OFF"));
 594         coex_dm->cur_dec_bt_pwr = dec_bt_pwr;
 595
 596         if (!force_exec) {
 597                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 598                             "[BTCoex], pre_dec_bt_pwr = %d, cur_dec_bt_pwr = %d\n",
 599                             coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
 600
 601                 if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
 602                         return;
 603         }
 604         halbtc8821a2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr);
 605
 606         coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr;
 607 }
 608
 609 static void btc8821a2ant_set_fw_bt_lna_constr(struct btc_coexist *btcoexist,
 610                                               bool bt_lna_cons_on)
 611 {
 612         u8 h2c_parameter[2] = {0};
 613
 614         h2c_parameter[0] = 0x3; /* opCode, 0x3 = BT_SET_LNA_CONSTRAIN */
 615
 616         if (bt_lna_cons_on)
 617                 h2c_parameter[1] |= BIT0;
 618
 619         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 620                     "[BTCoex], set BT LNA Constrain: %s, FW write 0x69 = 0x%x\n",
 621                     bt_lna_cons_on ? "ON!!" : "OFF!!",
 622                     h2c_parameter[0] << 8 | h2c_parameter[1]);
 623
 624         btcoexist->btc_fill_h2c(btcoexist, 0x69, 2, h2c_parameter);
 625 }
 626
 627 static void btc8821a2_set_bt_lna_const(struct btc_coexist *btcoexist,
 628                                        bool force_exec, bool bt_lna_cons_on)
 629 {
 630         btc_alg_dbg(ALGO_TRACE_FW,
 631                     "[BTCoex], %s BT Constrain = %s\n",
 632                     (force_exec ? "force" : ""),
 633                     ((bt_lna_cons_on) ? "ON" : "OFF"));
 634         coex_dm->cur_bt_lna_constrain = bt_lna_cons_on;
 635
 636         if (!force_exec) {
 637                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 638                             "[BTCoex], pre_bt_lna_constrain = %d,cur_bt_lna_constrain = %d\n",
 639                             coex_dm->pre_bt_lna_constrain,
 640                             coex_dm->cur_bt_lna_constrain);
 641
 642                 if (coex_dm->pre_bt_lna_constrain ==
 643                     coex_dm->cur_bt_lna_constrain)
 644                         return;
 645         }
 646         btc8821a2ant_set_fw_bt_lna_constr(btcoexist,
 647                                           coex_dm->cur_bt_lna_constrain);
 648
 649         coex_dm->pre_bt_lna_constrain = coex_dm->cur_bt_lna_constrain;
 650 }
 651
 652 static void halbtc8821a2ant_set_fw_bt_psd_mode(struct btc_coexist *btcoexist,
 653                                                u8 bt_psd_mode)
 654 {
 655         u8 h2c_parameter[2] = {0};
 656
 657         h2c_parameter[0] = 0x2; /* opCode, 0x2 = BT_SET_PSD_MODE */
 658
 659         h2c_parameter[1] = bt_psd_mode;
 660
 661         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 662                     "[BTCoex], set BT PSD mode = 0x%x, FW write 0x69 = 0x%x\n",
 663                     h2c_parameter[1],
 664                     h2c_parameter[0] << 8 | h2c_parameter[1]);
 665
 666         btcoexist->btc_fill_h2c(btcoexist, 0x69, 2, h2c_parameter);
 667 }
 668
 669 static void halbtc8821a2ant_set_bt_psd_mode(struct btc_coexist *btcoexist,
 670                                             bool force_exec, u8 bt_psd_mode)
 671 {
 672         btc_alg_dbg(ALGO_TRACE_FW,
 673                     "[BTCoex], %s BT PSD mode = 0x%x\n",
 674                     (force_exec ? "force" : ""), bt_psd_mode);
 675         coex_dm->cur_bt_psd_mode = bt_psd_mode;
 676
 677         if (!force_exec) {
 678                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 679                             "[BTCoex], pre_bt_psd_mode = 0x%x, cur_bt_psd_mode = 0x%x\n",
 680                             coex_dm->pre_bt_psd_mode, coex_dm->cur_bt_psd_mode);
 681
 682                 if (coex_dm->pre_bt_psd_mode == coex_dm->cur_bt_psd_mode)
 683                         return;
 684         }
 685         halbtc8821a2ant_set_fw_bt_psd_mode(btcoexist,
 686                                            coex_dm->cur_bt_psd_mode);
 687
 688         coex_dm->pre_bt_psd_mode = coex_dm->cur_bt_psd_mode;
 689 }
 690
 691 static void halbtc8821a2ant_set_bt_auto_report(struct btc_coexist *btcoexist,
 692                                                bool enable_auto_report)
 693 {
 694         u8 h2c_parameter[1] = {0};
 695
 696         h2c_parameter[0] = 0;
 697
 698         if (enable_auto_report)
 699                 h2c_parameter[0] |= BIT0;
 700
 701         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 702                     "[BTCoex], BT FW auto report : %s, FW write 0x68 = 0x%x\n",
 703                     (enable_auto_report ? "Enabled!!" : "Disabled!!"),
 704                     h2c_parameter[0]);
 705
 706         btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter);
 707 }
 708
 709 static void halbtc8821a2ant_bt_auto_report(struct btc_coexist *btcoexist,
 710                                            bool force_exec,
 711                                            bool enable_auto_report)
 712 {
 713         btc_alg_dbg(ALGO_TRACE_FW,
 714                     "[BTCoex], %s BT Auto report = %s\n",
 715                     (force_exec ? "force to" : ""),
 716                     ((enable_auto_report) ? "Enabled" : "Disabled"));
 717         coex_dm->cur_bt_auto_report = enable_auto_report;
 718
 719         if (!force_exec) {
 720                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 721                             "[BTCoex], pre_bt_auto_report = %d, cur_bt_auto_report = %d\n",
 722                             coex_dm->pre_bt_auto_report,
 723                             coex_dm->cur_bt_auto_report);
 724
 725                 if (coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report)
 726                         return;
 727         }
 728         halbtc8821a2ant_set_bt_auto_report(btcoexist,
 729                                            coex_dm->cur_bt_auto_report);
 730
 731         coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report;
 732 }
 733
 734 static void halbtc8821a2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
 735                                              bool force_exec,
 736                                              u8 fw_dac_swing_lvl)
 737 {
 738         btc_alg_dbg(ALGO_TRACE_FW,
 739                     "[BTCoex], %s set FW Dac Swing level = %d\n",
 740                     (force_exec ? "force to" : ""), fw_dac_swing_lvl);
 741         coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 742
 743         if (!force_exec) {
 744                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
 745                             "[BTCoex], pre_fw_dac_swing_lvl = %d, cur_fw_dac_swing_lvl = %d\n",
 746                             coex_dm->pre_fw_dac_swing_lvl,
 747                             coex_dm->cur_fw_dac_swing_lvl);
 748
 749                 if (coex_dm->pre_fw_dac_swing_lvl ==
 750                     coex_dm->cur_fw_dac_swing_lvl)
 751                         return;
 752         }
 753
 754         btc8821a2ant_set_fw_dac_swing_lev(btcoexist,
 755                                           coex_dm->cur_fw_dac_swing_lvl);
 756
 757         coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
 758 }
 759
 760 static void btc8821a2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 761                                                  bool rx_rf_shrink_on)
 762 {
 763         if (rx_rf_shrink_on) {
 764                 /* Shrink RF Rx LPF corner */
 765                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 766                             "[BTCoex], Shrink RF Rx LPF corner!!\n");
 767                 btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
 768                                           0xfffff, 0xffffc);
 769         } else {
 770                 /* Resume RF Rx LPF corner
 771                  * After initialized, we can use coex_dm->bt_rf0x1e_backup
 772                  */
 773                 if (btcoexist->initilized) {
 774                         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 775                                     "[BTCoex], Resume RF Rx LPF corner!!\n");
 776                         btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
 777                                                   0x1e, 0xfffff,
 778                                                    coex_dm->bt_rf0x1e_backup);
 779                 }
 780         }
 781 }
 782
 783 static void halbtc8821a2ant_RfShrink(struct btc_coexist *btcoexist,
 784                                      bool force_exec, bool rx_rf_shrink_on)
 785 {
 786         btc_alg_dbg(ALGO_TRACE_SW,
 787                     "[BTCoex], %s turn Rx RF Shrink = %s\n",
 788                     (force_exec ? "force to" : ""),
 789                     ((rx_rf_shrink_on) ? "ON" : "OFF"));
 790         coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 791
 792         if (!force_exec) {
 793                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 794                             "[BTCoex], pre_rf_rx_lpf_shrink = %d, cur_rf_rx_lpf_shrink = %d\n",
 795                             coex_dm->pre_rf_rx_lpf_shrink,
 796                             coex_dm->cur_rf_rx_lpf_shrink);
 797
 798                 if (coex_dm->pre_rf_rx_lpf_shrink ==
 799                     coex_dm->cur_rf_rx_lpf_shrink)
 800                         return;
 801         }
 802         btc8821a2ant_set_sw_rf_rx_lpf_corner(btcoexist,
 803                                              coex_dm->cur_rf_rx_lpf_shrink);
 804
 805         coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
 806 }
 807
 808 static void btc8821a2ant_SetSwPenTxRateAdapt(struct btc_coexist *btcoexist,
 809                                              bool low_penalty_ra)
 810 {
 811         u8 h2c_parameter[6] = {0};
 812
 813         h2c_parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
 814
 815         if (low_penalty_ra) {
 816                 h2c_parameter[1] |= BIT0;
 817                 /*normal rate except MCS7/6/5, OFDM54/48/36 */
 818                 h2c_parameter[2] = 0x00;
 819                 /*MCS7 or OFDM54 */
 820                 h2c_parameter[3] = 0xf7;
 821                 /*MCS6 or OFDM48 */
 822                 h2c_parameter[4] = 0xf8;
 823                 /*MCS5 or OFDM36 */
 824                 h2c_parameter[5] = 0xf9;
 825         }
 826
 827         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
 828                     "[BTCoex], set WiFi Low-Penalty Retry: %s",
 829                     (low_penalty_ra ? "ON!!" : "OFF!!"));
 830
 831         btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 832 }
 833
 834 static void halbtc8821a2ant_low_penalty_ra(struct btc_coexist *btcoexist,
 835                                            bool force_exec, bool low_penalty_ra)
 836 {
 837         /*return;*/
 838         btc_alg_dbg(ALGO_TRACE_SW,
 839                     "[BTCoex], %s turn LowPenaltyRA = %s\n",
 840                     (force_exec ? "force to" : ""),
 841                     ((low_penalty_ra) ? "ON" : "OFF"));
 842         coex_dm->cur_low_penalty_ra = low_penalty_ra;
 843
 844         if (!force_exec) {
 845                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 846                             "[BTCoex], pre_low_penalty_ra = %d, cur_low_penalty_ra = %d\n",
 847                             coex_dm->pre_low_penalty_ra,
 848                             coex_dm->cur_low_penalty_ra);
 849
 850                 if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 851                         return;
 852         }
 853         btc8821a2ant_SetSwPenTxRateAdapt(btcoexist,
 854                                          coex_dm->cur_low_penalty_ra);
 855
 856         coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 857 }
 858
 859 static void halbtc8821a2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
 860                                               u32 level)
 861 {
 862         u8 val = (u8)level;
 863
 864         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 865                     "[BTCoex], Write SwDacSwing = 0x%x\n", level);
 866         btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc5b, 0x3e, val);
 867 }
 868
 869 static void btc8821a2ant_set_sw_full_dac_swing(struct btc_coexist *btcoexist,
 870                                                bool sw_dac_swing_on,
 871                                                u32 sw_dac_swing_lvl)
 872 {
 873         if (sw_dac_swing_on)
 874                 halbtc8821a2ant_set_dac_swing_reg(btcoexist, sw_dac_swing_lvl);
 875         else
 876                 halbtc8821a2ant_set_dac_swing_reg(btcoexist, 0x18);
 877 }
 878
 879 static void halbtc8821a2ant_dac_swing(struct btc_coexist *btcoexist,
 880                                       bool force_exec, bool dac_swing_on,
 881                                       u32 dac_swing_lvl)
 882 {
 883         btc_alg_dbg(ALGO_TRACE_SW,
 884                     "[BTCoex], %s turn DacSwing = %s, dac_swing_lvl = 0x%x\n",
 885                     (force_exec ? "force to" : ""),
 886                     ((dac_swing_on) ? "ON" : "OFF"),
 887                     dac_swing_lvl);
 888         coex_dm->cur_dac_swing_on = dac_swing_on;
 889         coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 890
 891         if (!force_exec) {
 892                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 893                             "[BTCoex], pre_dac_swing_on = %d, pre_dac_swing_lvl = 0x%x, cur_dac_swing_on = %d, cur_dac_swing_lvl = 0x%x\n",
 894                             coex_dm->pre_dac_swing_on,
 895                             coex_dm->pre_dac_swing_lvl,
 896                             coex_dm->cur_dac_swing_on,
 897                             coex_dm->cur_dac_swing_lvl);
 898
 899                 if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
 900                     (coex_dm->pre_dac_swing_lvl ==
 901                      coex_dm->cur_dac_swing_lvl))
 902                         return;
 903         }
 904         mdelay(30);
 905         btc8821a2ant_set_sw_full_dac_swing(btcoexist, dac_swing_on,
 906                                            dac_swing_lvl);
 907
 908         coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
 909         coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
 910 }
 911
 912 static void halbtc8821a2ant_set_adc_back_off(struct btc_coexist *btcoexist,
 913                                              bool adc_back_off)
 914 {
 915         if (adc_back_off) {
 916                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 917                             "[BTCoex], BB BackOff Level On!\n");
 918                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x3);
 919         } else {
 920                 btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 921                             "[BTCoex], BB BackOff Level Off!\n");
 922                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x1);
 923         }
 924 }
 925
 926 static void halbtc8821a2ant_adc_back_off(struct btc_coexist *btcoexist,
 927                                          bool force_exec, bool adc_back_off)
 928 {
 929         btc_alg_dbg(ALGO_TRACE_SW,
 930                     "[BTCoex], %s turn AdcBackOff = %s\n",
 931                     (force_exec ? "force to" : ""),
 932                     ((adc_back_off) ? "ON" : "OFF"));
 933         coex_dm->cur_adc_back_off = adc_back_off;
 934
 935         if (!force_exec) {
 936                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 937                             "[BTCoex], pre_adc_back_off = %d, cur_adc_back_off = %d\n",
 938                             coex_dm->pre_adc_back_off,
 939                             coex_dm->cur_adc_back_off);
 940
 941                 if (coex_dm->pre_adc_back_off == coex_dm->cur_adc_back_off)
 942                         return;
 943         }
 944         halbtc8821a2ant_set_adc_back_off(btcoexist, coex_dm->cur_adc_back_off);
 945
 946         coex_dm->pre_adc_back_off = coex_dm->cur_adc_back_off;
 947 }
 948
 949 static void halbtc8821a2ant_set_coex_table(struct btc_coexist *btcoexist,
 950                                            u32 val0x6c0, u32 val0x6c4,
 951                                            u32 val0x6c8, u8 val0x6cc)
 952 {
 953         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 954                     "[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0);
 955         btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 956
 957         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 958                     "[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4);
 959         btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 960
 961         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 962                     "[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8);
 963         btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 964
 965         btc_alg_dbg(ALGO_TRACE_SW_EXEC,
 966                     "[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc);
 967         btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 968 }
 969
 970 static void halbtc8821a2ant_coex_table(struct btc_coexist *btcoexist,
 971                                        bool force_exec, u32 val0x6c0,
 972                                        u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
 973 {
 974         btc_alg_dbg(ALGO_TRACE_SW,
 975                     "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
 976                     (force_exec ? "force to" : ""),
 977                     val0x6c0, val0x6c4, val0x6c8, val0x6cc);
 978         coex_dm->cur_val0x6c0 = val0x6c0;
 979         coex_dm->cur_val0x6c4 = val0x6c4;
 980         coex_dm->cur_val0x6c8 = val0x6c8;
 981         coex_dm->cur_val0x6cc = val0x6cc;
 982
 983         if (!force_exec) {
 984                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 985                             "[BTCoex], pre_val0x6c0 = 0x%x, pre_val0x6c4 = 0x%x, pre_val0x6c8 = 0x%x, pre_val0x6cc = 0x%x !!\n",
 986                             coex_dm->pre_val0x6c0,
 987                             coex_dm->pre_val0x6c4,
 988                             coex_dm->pre_val0x6c8,
 989                             coex_dm->pre_val0x6cc);
 990                 btc_alg_dbg(ALGO_TRACE_SW_DETAIL,
 991                             "[BTCoex], cur_val0x6c0 = 0x%x, cur_val0x6c4 = 0x%x, cur_val0x6c8 = 0x%x, cur_val0x6cc = 0x%x !!\n",
 992                             coex_dm->cur_val0x6c0,
 993                             coex_dm->cur_val0x6c4,
 994                             coex_dm->cur_val0x6c8,
 995                             coex_dm->cur_val0x6cc);
 996
 997                 if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
 998                     (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
 999                     (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1000                     (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1001                         return;
1002         }
1003         halbtc8821a2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4, val0x6c8,
1004                                        val0x6cc);
1005
1006         coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1007         coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1008         coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1009         coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1010 }
1011
1012 static void halbtc8821a2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoex,
1013                                                    bool enable)
1014 {
1015         u8 h2c_parameter[1] = {0};
1016
1017         if (enable)
1018                 h2c_parameter[0] |= BIT0;/* function enable */
1019
1020         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
1021                     "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
1022                     h2c_parameter[0]);
1023
1024         btcoex->btc_fill_h2c(btcoex, 0x63, 1, h2c_parameter);
1025 }
1026
1027 static void halbtc8821a2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1028                                             bool force_exec, bool enable)
1029 {
1030         btc_alg_dbg(ALGO_TRACE_FW,
1031                     "[BTCoex], %s turn Ignore WlanAct %s\n",
1032                     (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1033         coex_dm->cur_ignore_wlan_act = enable;
1034
1035         if (!force_exec) {
1036                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1037                             "[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n",
1038                             coex_dm->pre_ignore_wlan_act,
1039                             coex_dm->cur_ignore_wlan_act);
1040
1041                 if (coex_dm->pre_ignore_wlan_act ==
1042                     coex_dm->cur_ignore_wlan_act)
1043                         return;
1044         }
1045         halbtc8821a2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1046
1047         coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1048 }
1049
1050 static void halbtc8821a2ant_set_fw_pstdma(struct btc_coexist *btcoexist,
1051                                           u8 byte1, u8 byte2, u8 byte3,
1052                                           u8 byte4, u8 byte5)
1053 {
1054         u8 h2c_parameter[5];
1055
1056         h2c_parameter[0] = byte1;
1057         h2c_parameter[1] = byte2;
1058         h2c_parameter[2] = byte3;
1059         h2c_parameter[3] = byte4;
1060         h2c_parameter[4] = byte5;
1061
1062         coex_dm->ps_tdma_para[0] = byte1;
1063         coex_dm->ps_tdma_para[1] = byte2;
1064         coex_dm->ps_tdma_para[2] = byte3;
1065         coex_dm->ps_tdma_para[3] = byte4;
1066         coex_dm->ps_tdma_para[4] = byte5;
1067
1068         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
1069                     "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1070                     h2c_parameter[0],
1071                     h2c_parameter[1] << 24 |
1072                     h2c_parameter[2] << 16 |
1073                     h2c_parameter[3] << 8 |
1074                     h2c_parameter[4]);
1075
1076         btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1077 }
1078
1079 static void btc8821a2ant_sw_mech1(struct btc_coexist *btcoexist,
1080                                   bool shrink_rx_lpf,
1081                                   bool low_penalty_ra, bool limited_dig,
1082                                   bool bt_lna_constrain)
1083 {
1084         u32 wifi_bw;
1085
1086         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
1087
1088         if (BTC_WIFI_BW_HT40 != wifi_bw) {
1089                 /*only shrink RF Rx LPF for HT40*/
1090                 if (shrink_rx_lpf)
1091                         shrink_rx_lpf = false;
1092         }
1093
1094         halbtc8821a2ant_RfShrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf);
1095         halbtc8821a2ant_low_penalty_ra(btcoexist,
1096                                        NORMAL_EXEC, low_penalty_ra);
1097
1098         /* no limited DIG
1099          * btc8821a2_set_bt_lna_const(btcoexist,
1100                 NORMAL_EXEC, bBTLNAConstrain);
1101          */
1102 }
1103
1104 static void btc8821a2ant_sw_mech2(struct btc_coexist *btcoexist,
1105                                   bool agc_table_shift,
1106                                   bool adc_back_off, bool sw_dac_swing,
1107                                   u32 dac_swing_lvl)
1108 {
1109         /* halbtc8821a2ant_AgcTable(btcoexist, NORMAL_EXEC, bAGCTableShift); */
1110         halbtc8821a2ant_adc_back_off(btcoexist, NORMAL_EXEC, adc_back_off);
1111         halbtc8821a2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1112                                   sw_dac_swing);
1113 }
1114
1115 static void halbtc8821a2ant_set_ant_path(struct btc_coexist *btcoexist,
1116                                          u8 ant_pos_type, bool init_hw_cfg,
1117                                          bool wifi_off)
1118 {
1119         struct btc_board_info *board_info = &btcoexist->board_info;
1120         u32 u4tmp = 0;
1121         u8 h2c_parameter[2] = {0};
1122
1123         if (init_hw_cfg) {
1124                 /*  0x4c[23] = 0, 0x4c[24] = 1  Antenna control by WL/BT */
1125                 u4tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
1126                 u4tmp &= ~BIT23;
1127                 u4tmp |= BIT24;
1128                 btcoexist->btc_write_4byte(btcoexist, 0x4c, u4tmp);
1129
1130                 btcoexist->btc_write_4byte(btcoexist, 0x974, 0x3ff);
1131                 btcoexist->btc_write_1byte(btcoexist, 0xcb4, 0x77);
1132
1133                 if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
1134                         /* tell firmware "antenna inverse"  ==>
1135                          *      WRONG firmware antenna control code.
1136                          *      ==>need fw to fix
1137                          */
1138                         h2c_parameter[0] = 1;
1139                         h2c_parameter[1] = 1;
1140                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1141                                                 h2c_parameter);
1142                 } else {
1143                         /* tell firmware "no antenna inverse"
1144                          *      ==> WRONG firmware antenna control code.
1145                          *      ==>need fw to fix
1146                          */
1147                         h2c_parameter[0] = 0;
1148                         h2c_parameter[1] = 1;
1149                         btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
1150                                                 h2c_parameter);
1151                 }
1152         }
1153
1154         /* ext switch setting */
1155         switch (ant_pos_type) {
1156         case BTC_ANT_WIFI_AT_MAIN:
1157                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x1);
1158                 break;
1159         case BTC_ANT_WIFI_AT_AUX:
1160                 btcoexist->btc_write_1byte_bitmask(btcoexist, 0xcb7, 0x30, 0x2);
1161                 break;
1162         }
1163 }
1164
1165 static void halbtc8821a2ant_ps_tdma(struct btc_coexist *btcoexist,
1166                                     bool force_exec, bool turn_on, u8 type)
1167 {
1168         btc_alg_dbg(ALGO_TRACE_FW,
1169                     "[BTCoex], %s turn %s PS TDMA, type = %d\n",
1170                     (force_exec ? "force to" : ""), (turn_on ? "ON" : "OFF"),
1171                     type);
1172         coex_dm->cur_ps_tdma_on = turn_on;
1173         coex_dm->cur_ps_tdma = type;
1174
1175         if (!force_exec) {
1176                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1177                             "[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n",
1178                             coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1179                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1180                             "[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n",
1181                             coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1182
1183                 if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1184                     (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1185                         return;
1186         }
1187         if (turn_on) {
1188                 switch (type) {
1189                 case 1:
1190                 default:
1191                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1a,
1192                                                       0x1a, 0xe1, 0x90);
1193                         break;
1194                 case 2:
1195                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x12,
1196                                                       0x12, 0xe1, 0x90);
1197                         break;
1198                 case 3:
1199                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1c,
1200                                                       0x3, 0xf1, 0x90);
1201                         break;
1202                 case 4:
1203                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x10,
1204                                                       0x03, 0xf1, 0x90);
1205                         break;
1206                 case 5:
1207                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1a,
1208                                                       0x1a, 0x60, 0x90);
1209                         break;
1210                 case 6:
1211                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x12,
1212                                                       0x12, 0x60, 0x90);
1213                         break;
1214                 case 7:
1215                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1c,
1216                                                       0x3, 0x70, 0x90);
1217                         break;
1218                 case 8:
1219                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xa3, 0x10,
1220                                                       0x3, 0x70, 0x90);
1221                         break;
1222                 case 9:
1223                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1a,
1224                                                       0x1a, 0xe1, 0x90);
1225                         break;
1226                 case 10:
1227                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x12,
1228                                                       0x12, 0xe1, 0x90);
1229                         break;
1230                 case 11:
1231                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0xa,
1232                                                       0xa, 0xe1, 0x90);
1233                         break;
1234                 case 12:
1235                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x5,
1236                                                       0x5, 0xe1, 0x90);
1237                         break;
1238                 case 13:
1239                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1a,
1240                                                       0x1a, 0x60, 0x90);
1241                         break;
1242                 case 14:
1243                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3,
1244                                                       0x12, 0x12, 0x60, 0x90);
1245                         break;
1246                 case 15:
1247                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0xa,
1248                                                       0xa, 0x60, 0x90);
1249                         break;
1250                 case 16:
1251                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x5,
1252                                                       0x5, 0x60, 0x90);
1253                         break;
1254                 case 17:
1255                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xa3, 0x2f,
1256                                                       0x2f, 0x60, 0x90);
1257                         break;
1258                 case 18:
1259                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x5,
1260                                                       0x5, 0xe1, 0x90);
1261                         break;
1262                 case 19:
1263                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x25,
1264                                                       0x25, 0xe1, 0x90);
1265                         break;
1266                 case 20:
1267                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x25,
1268                                                       0x25, 0x60, 0x90);
1269                         break;
1270                 case 21:
1271                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x15,
1272                                                       0x03, 0x70, 0x90);
1273                         break;
1274                 case 71:
1275                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0xe3, 0x1a,
1276                                                       0x1a, 0xe1, 0x90);
1277                         break;
1278                 }
1279         } else {
1280                 /* disable PS tdma */
1281                 switch (type) {
1282                 case 0:
1283                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1284                                                       0x40, 0x0);
1285                         break;
1286                 case 1:
1287                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1288                                                       0x48, 0x0);
1289                         break;
1290                 default:
1291                         halbtc8821a2ant_set_fw_pstdma(btcoexist, 0x0, 0x0, 0x0,
1292                                                       0x40, 0x0);
1293                         break;
1294                 }
1295         }
1296
1297         /* update pre state */
1298         coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1299         coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1300 }
1301
1302 static void halbtc8821a2ant_coex_all_off(struct btc_coexist *btcoexist)
1303 {
1304         /* fw all off */
1305         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1306         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1307         halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1308
1309         /* sw all off */
1310         btc8821a2ant_sw_mech1(btcoexist, false, false, false, false);
1311         btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1312
1313         /* hw all off */
1314         halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC,
1315                                    0x55555555, 0x55555555, 0xffff, 0x3);
1316 }
1317
1318 static void halbtc8821a2ant_coex_under_5g(struct btc_coexist *btcoexist)
1319 {
1320         halbtc8821a2ant_coex_all_off(btcoexist);
1321 }
1322
1323 static void halbtc8821a2ant_init_coex_dm(struct btc_coexist *btcoexist)
1324 {
1325         /* force to reset coex mechanism */
1326         halbtc8821a2ant_coex_table(btcoexist, FORCE_EXEC, 0x55555555,
1327                                    0x55555555, 0xffff, 0x3);
1328
1329         halbtc8821a2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1330         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1331         halbtc8821a2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false);
1332
1333         btc8821a2ant_sw_mech1(btcoexist, false, false, false, false);
1334         btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1335 }
1336
1337 static void halbtc8821a2ant_bt_inquiry_page(struct btc_coexist *btcoexist)
1338 {
1339         bool low_pwr_disable = true;
1340
1341         btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1342                            &low_pwr_disable);
1343
1344         halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
1345                                    0x5afa5afa, 0xffff, 0x3);
1346         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1347 }
1348
1349 static bool halbtc8821a2ant_is_common_action(struct btc_coexist *btcoexist)
1350 {
1351         bool common = false, wifi_connected = false, wifi_busy = false;
1352         bool low_pwr_disable = false;
1353
1354         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1355                            &wifi_connected);
1356         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1357
1358         halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
1359                                    0x5afa5afa, 0xffff, 0x3);
1360
1361         if (!wifi_connected &&
1362             BT_8821A_2ANT_BT_STATUS_IDLE == coex_dm->bt_status) {
1363                 low_pwr_disable = false;
1364                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1365                                    &low_pwr_disable);
1366
1367                 btc_alg_dbg(ALGO_TRACE,
1368                             "[BTCoex], Wifi IPS + BT IPS!!\n");
1369
1370                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1371                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1372                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1373
1374                 btc8821a2ant_sw_mech1(btcoexist, false, false, false, false);
1375                 btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1376
1377                 common = true;
1378         } else if (wifi_connected &&
1379                    (BT_8821A_2ANT_BT_STATUS_IDLE == coex_dm->bt_status)) {
1380                 low_pwr_disable = false;
1381                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1382                                    &low_pwr_disable);
1383
1384                 if (wifi_busy) {
1385                         btc_alg_dbg(ALGO_TRACE,
1386                                     "[BTCoex], Wifi Busy + BT IPS!!\n");
1387                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1388                                                 false, 1);
1389                 } else {
1390                         btc_alg_dbg(ALGO_TRACE,
1391                                     "[BTCoex], Wifi LPS + BT IPS!!\n");
1392                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1393                                                 false, 1);
1394                 }
1395
1396                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1397                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1398
1399                 btc8821a2ant_sw_mech1(btcoexist, false, false, false, false);
1400                 btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1401
1402                 common = true;
1403         } else if (!wifi_connected &&
1404                    (BT_8821A_2ANT_BT_STATUS_CON_IDLE == coex_dm->bt_status)) {
1405                 low_pwr_disable = true;
1406                 btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1407                                    &low_pwr_disable);
1408
1409                 btc_alg_dbg(ALGO_TRACE,
1410                             "[BTCoex], Wifi IPS + BT LPS!!\n");
1411
1412                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1413                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1414                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1415
1416                 btc8821a2ant_sw_mech1(btcoexist, false, false, false, false);
1417                 btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1418                 common = true;
1419         } else if (wifi_connected &&
1420                    (BT_8821A_2ANT_BT_STATUS_CON_IDLE == coex_dm->bt_status)) {
1421                 low_pwr_disable = true;
1422                 btcoexist->btc_set(btcoexist,
1423                         BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_disable);
1424
1425                 if (wifi_busy) {
1426                         btc_alg_dbg(ALGO_TRACE,
1427                                     "[BTCoex], Wifi Busy + BT LPS!!\n");
1428                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1429                                                 false, 1);
1430                 } else {
1431                         btc_alg_dbg(ALGO_TRACE,
1432                                     "[BTCoex], Wifi LPS + BT LPS!!\n");
1433                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1434                                                 false, 1);
1435                 }
1436
1437                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1438                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1439
1440                 btc8821a2ant_sw_mech1(btcoexist, true, true, true, true);
1441                 btc8821a2ant_sw_mech2(btcoexist, false, false, false, 0x18);
1442
1443                 common = true;
1444         } else if (!wifi_connected &&
1445                    (BT_8821A_2ANT_BT_STATUS_NON_IDLE ==
1446                     coex_dm->bt_status)) {
1447                 low_pwr_disable = false;
1448                 btcoexist->btc_set(btcoexist,
1449                         BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_disable);
1450
1451                 btc_alg_dbg(ALGO_TRACE,
1452                             "[BTCoex], Wifi IPS + BT Busy!!\n");
1453
1454                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1455                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1456                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1457
1458                 btc8821a2ant_sw_mech1(btcoexist, false, false,
1459                                       false, false);
1460                 btc8821a2ant_sw_mech2(btcoexist, false, false,
1461                                       false, 0x18);
1462
1463                 common = true;
1464         } else {
1465                 low_pwr_disable = true;
1466                 btcoexist->btc_set(btcoexist,
1467                                    BTC_SET_ACT_DISABLE_LOW_POWER,
1468                                    &low_pwr_disable);
1469
1470                 if (wifi_busy) {
1471                         btc_alg_dbg(ALGO_TRACE,
1472                                     "[BTCoex], Wifi Busy + BT Busy!!\n");
1473                         common = false;
1474                 } else {
1475                         btc_alg_dbg(ALGO_TRACE,
1476                                     "[BTCoex], Wifi LPS + BT Busy!!\n");
1477                         halbtc8821a2ant_ps_tdma(btcoexist,
1478                                                 NORMAL_EXEC, true, 21);
1479
1480                         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
1481                                 halbtc8821a2ant_dec_bt_pwr(btcoexist,
1482                                                            NORMAL_EXEC, true);
1483                         else
1484                                 halbtc8821a2ant_dec_bt_pwr(btcoexist,
1485                                                            NORMAL_EXEC, false);
1486
1487                         common = true;
1488                 }
1489                 btc8821a2ant_sw_mech1(btcoexist, true, true, true, true);
1490         }
1491         return common;
1492 }
1493
1494 static void btc8821a2_int1(struct btc_coexist *btcoexist, bool tx_pause,
1495                            int result)
1496 {
1497         if (tx_pause) {
1498                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1499                             "[BTCoex], TxPause = 1\n");
1500
1501                 if (coex_dm->cur_ps_tdma == 71) {
1502                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1503                                                 true, 5);
1504                         coex_dm->tdma_adj_type = 5;
1505                 } else if (coex_dm->cur_ps_tdma == 1) {
1506                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1507                                                 true, 5);
1508                         coex_dm->tdma_adj_type = 5;
1509                 } else if (coex_dm->cur_ps_tdma == 2) {
1510                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1511                                                 true, 6);
1512                         coex_dm->tdma_adj_type = 6;
1513                 } else if (coex_dm->cur_ps_tdma == 3) {
1514                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1515                                                 true, 7);
1516                         coex_dm->tdma_adj_type = 7;
1517                 } else if (coex_dm->cur_ps_tdma == 4) {
1518                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1519                                                 true, 8);
1520                         coex_dm->tdma_adj_type = 8;
1521                 }
1522                 if (coex_dm->cur_ps_tdma == 9) {
1523                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1524                                                 true, 13);
1525                         coex_dm->tdma_adj_type = 13;
1526                 } else if (coex_dm->cur_ps_tdma == 10) {
1527                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1528                                                 true, 14);
1529                         coex_dm->tdma_adj_type = 14;
1530                 } else if (coex_dm->cur_ps_tdma == 11) {
1531                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1532                                                 true, 15);
1533                         coex_dm->tdma_adj_type = 15;
1534                 } else if (coex_dm->cur_ps_tdma == 12) {
1535                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1536                                                 true, 16);
1537                         coex_dm->tdma_adj_type = 16;
1538                 }
1539
1540                 if (result == -1) {
1541                         if (coex_dm->cur_ps_tdma == 5) {
1542                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1543                                                         true, 6);
1544                                 coex_dm->tdma_adj_type = 6;
1545                         } else if (coex_dm->cur_ps_tdma == 6) {
1546                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1547                                                         true, 7);
1548                                 coex_dm->tdma_adj_type = 7;
1549                         } else if (coex_dm->cur_ps_tdma == 7) {
1550                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1551                                                         true, 8);
1552                                 coex_dm->tdma_adj_type = 8;
1553                         } else if (coex_dm->cur_ps_tdma == 13) {
1554                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1555                                                         true, 14);
1556                                 coex_dm->tdma_adj_type = 14;
1557                         } else if (coex_dm->cur_ps_tdma == 14) {
1558                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1559                                                         true, 15);
1560                                 coex_dm->tdma_adj_type = 15;
1561                         } else if (coex_dm->cur_ps_tdma == 15) {
1562                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1563                                                         true, 16);
1564                                 coex_dm->tdma_adj_type = 16;
1565                         }
1566                 } else if (result == 1) {
1567                         if (coex_dm->cur_ps_tdma == 8) {
1568                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1569                                                         true, 7);
1570                                 coex_dm->tdma_adj_type = 7;
1571                         } else if (coex_dm->cur_ps_tdma == 7) {
1572                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1573                                                         true, 6);
1574                                 coex_dm->tdma_adj_type = 6;
1575                         } else if (coex_dm->cur_ps_tdma == 6) {
1576                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1577                                                         true, 5);
1578                                 coex_dm->tdma_adj_type = 5;
1579                         } else if (coex_dm->cur_ps_tdma == 16) {
1580                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1581                                                         true, 15);
1582                                 coex_dm->tdma_adj_type = 15;
1583                         } else if (coex_dm->cur_ps_tdma == 15) {
1584                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1585                                                         true, 14);
1586                                 coex_dm->tdma_adj_type = 14;
1587                         } else if (coex_dm->cur_ps_tdma == 14) {
1588                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1589                                                         true, 13);
1590                                 coex_dm->tdma_adj_type = 13;
1591                         }
1592                 }
1593         } else {
1594                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1595                             "[BTCoex], TxPause = 0\n");
1596                 if (coex_dm->cur_ps_tdma == 5) {
1597                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1598                                                 true, 71);
1599                         coex_dm->tdma_adj_type = 71;
1600                 } else if (coex_dm->cur_ps_tdma == 6) {
1601                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1602                                                 true, 2);
1603                         coex_dm->tdma_adj_type = 2;
1604                 } else if (coex_dm->cur_ps_tdma == 7) {
1605                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1606                                                 true, 3);
1607                         coex_dm->tdma_adj_type = 3;
1608                 } else if (coex_dm->cur_ps_tdma == 8) {
1609                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1610                                                 true, 4);
1611                         coex_dm->tdma_adj_type = 4;
1612                 }
1613                 if (coex_dm->cur_ps_tdma == 13) {
1614                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1615                                                 true, 9);
1616                         coex_dm->tdma_adj_type = 9;
1617                 } else if (coex_dm->cur_ps_tdma == 14) {
1618                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1619                                                 true, 10);
1620                         coex_dm->tdma_adj_type = 10;
1621                 } else if (coex_dm->cur_ps_tdma == 15) {
1622                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1623                                                 true, 11);
1624                         coex_dm->tdma_adj_type = 11;
1625                 } else if (coex_dm->cur_ps_tdma == 16) {
1626                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1627                                                 true, 12);
1628                         coex_dm->tdma_adj_type = 12;
1629                 }
1630
1631                 if (result == -1) {
1632                         if (coex_dm->cur_ps_tdma == 71) {
1633                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1634                                                         true, 1);
1635                                 coex_dm->tdma_adj_type = 1;
1636                         } else if (coex_dm->cur_ps_tdma == 1) {
1637                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1638                                                         true, 2);
1639                                 coex_dm->tdma_adj_type = 2;
1640                         } else if (coex_dm->cur_ps_tdma == 2) {
1641                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1642                                                         true, 3);
1643                                 coex_dm->tdma_adj_type = 3;
1644                         } else if (coex_dm->cur_ps_tdma == 3) {
1645                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1646                                                         true, 4);
1647                                 coex_dm->tdma_adj_type = 4;
1648                         } else if (coex_dm->cur_ps_tdma == 9) {
1649                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1650                                                         true, 10);
1651                                 coex_dm->tdma_adj_type = 10;
1652                         } else if (coex_dm->cur_ps_tdma == 10) {
1653                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1654                                                         true, 11);
1655                                 coex_dm->tdma_adj_type = 11;
1656                         } else if (coex_dm->cur_ps_tdma == 11) {
1657                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1658                                                         true, 12);
1659                                 coex_dm->tdma_adj_type = 12;
1660                         }
1661                 } else if (result == 1) {
1662                         if (coex_dm->cur_ps_tdma == 4) {
1663                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1664                                                         true, 3);
1665                                 coex_dm->tdma_adj_type = 3;
1666                         } else if (coex_dm->cur_ps_tdma == 3) {
1667                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1668                                                         true, 2);
1669                                 coex_dm->tdma_adj_type = 2;
1670                         } else if (coex_dm->cur_ps_tdma == 2) {
1671                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1672                                                         true, 1);
1673                                 coex_dm->tdma_adj_type = 1;
1674                         } else if (coex_dm->cur_ps_tdma == 1) {
1675                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1676                                                         true, 71);
1677                                 coex_dm->tdma_adj_type = 71;
1678                         } else if (coex_dm->cur_ps_tdma == 12) {
1679                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1680                                                         true, 11);
1681                                 coex_dm->tdma_adj_type = 11;
1682                         } else if (coex_dm->cur_ps_tdma == 11) {
1683                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1684                                                         true, 10);
1685                                 coex_dm->tdma_adj_type = 10;
1686                         } else if (coex_dm->cur_ps_tdma == 10) {
1687                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1688                                                         true, 9);
1689                                 coex_dm->tdma_adj_type = 9;
1690                         }
1691                 }
1692         }
1693 }
1694
1695 static void btc8821a2_int2(struct btc_coexist *btcoexist, bool tx_pause,
1696                            int result)
1697 {
1698         if (tx_pause) {
1699                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1700                             "[BTCoex], TxPause = 1\n");
1701                 if (coex_dm->cur_ps_tdma == 1) {
1702                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1703                                                 true, 6);
1704                         coex_dm->tdma_adj_type = 6;
1705                 } else if (coex_dm->cur_ps_tdma == 2) {
1706                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1707                                                 true, 6);
1708                         coex_dm->tdma_adj_type = 6;
1709                 } else if (coex_dm->cur_ps_tdma == 3) {
1710                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1711                                                 true, 7);
1712                         coex_dm->tdma_adj_type = 7;
1713                 } else if (coex_dm->cur_ps_tdma == 4) {
1714                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1715                                                 true, 8);
1716                         coex_dm->tdma_adj_type = 8;
1717                 }
1718                 if (coex_dm->cur_ps_tdma == 9) {
1719                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1720                                                 true, 14);
1721                         coex_dm->tdma_adj_type = 14;
1722                 } else if (coex_dm->cur_ps_tdma == 10) {
1723                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1724                                                 true, 14);
1725                         coex_dm->tdma_adj_type = 14;
1726                 } else if (coex_dm->cur_ps_tdma == 11) {
1727                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1728                                                 true, 15);
1729                         coex_dm->tdma_adj_type = 15;
1730                 } else if (coex_dm->cur_ps_tdma == 12) {
1731                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1732                                                 true, 16);
1733                         coex_dm->tdma_adj_type = 16;
1734                 }
1735                 if (result == -1) {
1736                         if (coex_dm->cur_ps_tdma == 5) {
1737                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1738                                                         true, 6);
1739                                 coex_dm->tdma_adj_type = 6;
1740                         } else if (coex_dm->cur_ps_tdma == 6) {
1741                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1742                                                         true, 7);
1743                                 coex_dm->tdma_adj_type = 7;
1744                         } else if (coex_dm->cur_ps_tdma == 7) {
1745                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1746                                                         true, 8);
1747                                 coex_dm->tdma_adj_type = 8;
1748                         } else if (coex_dm->cur_ps_tdma == 13) {
1749                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1750                                                         true, 14);
1751                                 coex_dm->tdma_adj_type = 14;
1752                         } else if (coex_dm->cur_ps_tdma == 14) {
1753                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1754                                                         true, 15);
1755                                 coex_dm->tdma_adj_type = 15;
1756                         } else if (coex_dm->cur_ps_tdma == 15) {
1757                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1758                                                         true, 16);
1759                                 coex_dm->tdma_adj_type = 16;
1760                         }
1761                 } else if (result == 1) {
1762                         if (coex_dm->cur_ps_tdma == 8) {
1763                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1764                                                         true, 7);
1765                                 coex_dm->tdma_adj_type = 7;
1766                         } else if (coex_dm->cur_ps_tdma == 7) {
1767                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1768                                                         true, 6);
1769                                 coex_dm->tdma_adj_type = 6;
1770                         } else if (coex_dm->cur_ps_tdma == 6) {
1771                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1772                                                         true, 6);
1773                                 coex_dm->tdma_adj_type = 6;
1774                         } else if (coex_dm->cur_ps_tdma == 16) {
1775                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1776                                                         true, 15);
1777                                 coex_dm->tdma_adj_type = 15;
1778                         } else if (coex_dm->cur_ps_tdma == 15) {
1779                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1780                                                         true, 14);
1781                                 coex_dm->tdma_adj_type = 14;
1782                         } else if (coex_dm->cur_ps_tdma == 14) {
1783                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1784                                                         true, 14);
1785                                 coex_dm->tdma_adj_type = 14;
1786                         }
1787                 }
1788         } else {
1789                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1790                             "[BTCoex], TxPause = 0\n");
1791                 if (coex_dm->cur_ps_tdma == 5) {
1792                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1793                                                 true, 2);
1794                         coex_dm->tdma_adj_type = 2;
1795                 } else if (coex_dm->cur_ps_tdma == 6) {
1796                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1797                                                 true, 2);
1798                         coex_dm->tdma_adj_type = 2;
1799                 } else if (coex_dm->cur_ps_tdma == 7) {
1800                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1801                                                 true, 3);
1802                         coex_dm->tdma_adj_type = 3;
1803                 } else if (coex_dm->cur_ps_tdma == 8) {
1804                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1805                                                 true, 4);
1806                         coex_dm->tdma_adj_type = 4;
1807                 }
1808                 if (coex_dm->cur_ps_tdma == 13) {
1809                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1810                                                 true, 10);
1811                         coex_dm->tdma_adj_type = 10;
1812                 } else if (coex_dm->cur_ps_tdma == 14) {
1813                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1814                                                 true, 10);
1815                         coex_dm->tdma_adj_type = 10;
1816                 } else if (coex_dm->cur_ps_tdma == 15) {
1817                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1818                                                 true, 11);
1819                         coex_dm->tdma_adj_type = 11;
1820                 } else if (coex_dm->cur_ps_tdma == 16) {
1821                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1822                                                 true, 12);
1823                         coex_dm->tdma_adj_type = 12;
1824                 }
1825                 if (result == -1) {
1826                         if (coex_dm->cur_ps_tdma == 1) {
1827                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1828                                                         true, 2);
1829                                 coex_dm->tdma_adj_type = 2;
1830                         } else if (coex_dm->cur_ps_tdma == 2) {
1831                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1832                                                         true, 3);
1833                                 coex_dm->tdma_adj_type = 3;
1834                         } else if (coex_dm->cur_ps_tdma == 3) {
1835                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1836                                                         true, 4);
1837                                 coex_dm->tdma_adj_type = 4;
1838                         } else if (coex_dm->cur_ps_tdma == 9) {
1839                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1840                                                         true, 10);
1841                                 coex_dm->tdma_adj_type = 10;
1842                         } else if (coex_dm->cur_ps_tdma == 10) {
1843                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1844                                                         true, 11);
1845                                 coex_dm->tdma_adj_type = 11;
1846                         } else if (coex_dm->cur_ps_tdma == 11) {
1847                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1848                                                         true, 12);
1849                                 coex_dm->tdma_adj_type = 12;
1850                         }
1851                 } else if (result == 1) {
1852                         if (coex_dm->cur_ps_tdma == 4) {
1853                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1854                                                         true, 3);
1855                                 coex_dm->tdma_adj_type = 3;
1856                         } else if (coex_dm->cur_ps_tdma == 3) {
1857                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1858                                                         true, 2);
1859                                 coex_dm->tdma_adj_type = 2;
1860                         } else if (coex_dm->cur_ps_tdma == 2) {
1861                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1862                                                         true, 2);
1863                                 coex_dm->tdma_adj_type = 2;
1864                         } else if (coex_dm->cur_ps_tdma == 12) {
1865                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1866                                                         true, 11);
1867                                 coex_dm->tdma_adj_type = 11;
1868                         } else if (coex_dm->cur_ps_tdma == 11) {
1869                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1870                                                         true, 10);
1871                                 coex_dm->tdma_adj_type = 10;
1872                         } else if (coex_dm->cur_ps_tdma == 10) {
1873                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1874                                                         true, 10);
1875                                 coex_dm->tdma_adj_type = 10;
1876                         }
1877                 }
1878         }
1879 }
1880
1881 static void btc8821a2_int3(struct btc_coexist *btcoexist, bool tx_pause,
1882                            int result)
1883 {
1884         if (tx_pause) {
1885                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1886                             "[BTCoex], TxPause = 1\n");
1887                 if (coex_dm->cur_ps_tdma == 1) {
1888                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1889                                                 true, 7);
1890                         coex_dm->tdma_adj_type = 7;
1891                 } else if (coex_dm->cur_ps_tdma == 2) {
1892                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1893                                                 true, 7);
1894                         coex_dm->tdma_adj_type = 7;
1895                 } else if (coex_dm->cur_ps_tdma == 3) {
1896                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1897                                                 true, 7);
1898                         coex_dm->tdma_adj_type = 7;
1899                 } else if (coex_dm->cur_ps_tdma == 4) {
1900                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1901                                                 true, 8);
1902                         coex_dm->tdma_adj_type = 8;
1903                 }
1904                 if (coex_dm->cur_ps_tdma == 9) {
1905                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1906                                                 true, 15);
1907                         coex_dm->tdma_adj_type = 15;
1908                 } else if (coex_dm->cur_ps_tdma == 10) {
1909                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1910                                                 true, 15);
1911                         coex_dm->tdma_adj_type = 15;
1912                 } else if (coex_dm->cur_ps_tdma == 11) {
1913                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1914                                                 true, 15);
1915                         coex_dm->tdma_adj_type = 15;
1916                 } else if (coex_dm->cur_ps_tdma == 12) {
1917                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1918                                                 true, 16);
1919                         coex_dm->tdma_adj_type = 16;
1920                 }
1921                 if (result == -1) {
1922                         if (coex_dm->cur_ps_tdma == 5) {
1923                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1924                                                         true, 7);
1925                                 coex_dm->tdma_adj_type = 7;
1926                         } else if (coex_dm->cur_ps_tdma == 6) {
1927                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1928                                                         true, 7);
1929                                 coex_dm->tdma_adj_type = 7;
1930                         } else if (coex_dm->cur_ps_tdma == 7) {
1931                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1932                                                         true, 8);
1933                                 coex_dm->tdma_adj_type = 8;
1934                         } else if (coex_dm->cur_ps_tdma == 13) {
1935                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1936                                                         true, 15);
1937                                 coex_dm->tdma_adj_type = 15;
1938                         } else if (coex_dm->cur_ps_tdma == 14) {
1939                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1940                                                         true, 15);
1941                                 coex_dm->tdma_adj_type = 15;
1942                         } else if (coex_dm->cur_ps_tdma == 15) {
1943                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1944                                                         true, 16);
1945                                 coex_dm->tdma_adj_type = 16;
1946                         }
1947                 } else if (result == 1) {
1948                         if (coex_dm->cur_ps_tdma == 8) {
1949                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1950                                                         true, 7);
1951                                 coex_dm->tdma_adj_type = 7;
1952                         } else if (coex_dm->cur_ps_tdma == 7) {
1953                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1954                                                         true, 7);
1955                                 coex_dm->tdma_adj_type = 7;
1956                         } else if (coex_dm->cur_ps_tdma == 6) {
1957                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1958                                                         true, 7);
1959                                 coex_dm->tdma_adj_type = 7;
1960                         } else if (coex_dm->cur_ps_tdma == 16) {
1961                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1962                                                         true, 15);
1963                                 coex_dm->tdma_adj_type = 15;
1964                         } else if (coex_dm->cur_ps_tdma == 15) {
1965                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1966                                                         true, 15);
1967                                 coex_dm->tdma_adj_type = 15;
1968                         } else if (coex_dm->cur_ps_tdma == 14) {
1969                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1970                                                         true, 15);
1971                                 coex_dm->tdma_adj_type = 15;
1972                         }
1973                 }
1974         } else {
1975                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
1976                             "[BTCoex], TxPause = 0\n");
1977                 if (coex_dm->cur_ps_tdma == 5) {
1978                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1979                                                 true, 3);
1980                         coex_dm->tdma_adj_type = 3;
1981                 } else if (coex_dm->cur_ps_tdma == 6) {
1982                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1983                                                 true, 3);
1984                         coex_dm->tdma_adj_type = 3;
1985                 } else if (coex_dm->cur_ps_tdma == 7) {
1986                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1987                                                 true, 3);
1988                         coex_dm->tdma_adj_type = 3;
1989                 } else if (coex_dm->cur_ps_tdma == 8) {
1990                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1991                                                 true, 4);
1992                         coex_dm->tdma_adj_type = 4;
1993                 }
1994                 if (coex_dm->cur_ps_tdma == 13) {
1995                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1996                                                 true, 11);
1997                         coex_dm->tdma_adj_type = 11;
1998                 } else if (coex_dm->cur_ps_tdma == 14) {
1999                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2000                                                 true, 11);
2001                         coex_dm->tdma_adj_type = 11;
2002                 } else if (coex_dm->cur_ps_tdma == 15) {
2003                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2004                                                 true, 11);
2005                         coex_dm->tdma_adj_type = 11;
2006                 } else if (coex_dm->cur_ps_tdma == 16) {
2007                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2008                                                 true, 12);
2009                         coex_dm->tdma_adj_type = 12;
2010                 }
2011                 if (result == -1) {
2012                         if (coex_dm->cur_ps_tdma == 1) {
2013                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2014                                                         true, 3);
2015                                 coex_dm->tdma_adj_type = 3;
2016                         } else if (coex_dm->cur_ps_tdma == 2) {
2017                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2018                                                         true, 3);
2019                                 coex_dm->tdma_adj_type = 3;
2020                         } else if (coex_dm->cur_ps_tdma == 3) {
2021                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2022                                                         true, 4);
2023                                 coex_dm->tdma_adj_type = 4;
2024                         } else if (coex_dm->cur_ps_tdma == 9) {
2025                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2026                                                         true, 11);
2027                                 coex_dm->tdma_adj_type = 11;
2028                         } else if (coex_dm->cur_ps_tdma == 10) {
2029                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2030                                                         true, 11);
2031                                 coex_dm->tdma_adj_type = 11;
2032                         } else if (coex_dm->cur_ps_tdma == 11) {
2033                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2034                                                         true, 12);
2035                                 coex_dm->tdma_adj_type = 12;
2036                         }
2037                 } else if (result == 1) {
2038                         if (coex_dm->cur_ps_tdma == 4) {
2039                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2040                                                         true, 3);
2041                                 coex_dm->tdma_adj_type = 3;
2042                         } else if (coex_dm->cur_ps_tdma == 3) {
2043                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2044                                                         true, 3);
2045                                 coex_dm->tdma_adj_type = 3;
2046                         } else if (coex_dm->cur_ps_tdma == 2) {
2047                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2048                                                         true, 3);
2049                                 coex_dm->tdma_adj_type = 3;
2050                         } else if (coex_dm->cur_ps_tdma == 12) {
2051                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2052                                                         true, 11);
2053                                 coex_dm->tdma_adj_type = 11;
2054                         } else if (coex_dm->cur_ps_tdma == 11) {
2055                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2056                                                         true, 11);
2057                                 coex_dm->tdma_adj_type = 11;
2058                         } else if (coex_dm->cur_ps_tdma == 10) {
2059                                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2060                                                         true, 11);
2061                                 coex_dm->tdma_adj_type = 11;
2062                         }
2063                 }
2064         }
2065 }
2066
2067 static void btc8821a2ant_tdma_dur_adj(struct btc_coexist *btcoexist,
2068                                       bool sco_hid, bool tx_pause,
2069                                       u8 max_interval)
2070 {
2071         static long     up, dn, m, n, wait_count;
2072          /* 0: no change, +1: increase WiFi duration,
2073           * -1: decrease WiFi duration
2074           */
2075         int             result;
2076         u8              retry_count = 0;
2077
2078         btc_alg_dbg(ALGO_TRACE_FW,
2079                     "[BTCoex], TdmaDurationAdjust()\n");
2080
2081         if (coex_dm->reset_tdma_adjust) {
2082                 coex_dm->reset_tdma_adjust = false;
2083                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2084                             "[BTCoex], first run TdmaDurationAdjust()!!\n");
2085                 if (sco_hid) {
2086                         if (tx_pause) {
2087                                 if (max_interval == 1) {
2088                                         halbtc8821a2ant_ps_tdma(btcoexist,
2089                                                                 NORMAL_EXEC,
2090                                                                 true, 13);
2091                                         coex_dm->tdma_adj_type = 13;
2092                                 } else if (max_interval == 2) {
2093                                         halbtc8821a2ant_ps_tdma(btcoexist,
2094                                                                 NORMAL_EXEC,
2095                                                                 true, 14);
2096                                         coex_dm->tdma_adj_type = 14;
2097                                 } else if (max_interval == 3) {
2098                                         halbtc8821a2ant_ps_tdma(btcoexist,
2099                                                                 NORMAL_EXEC,
2100                                                                 true, 15);
2101                                         coex_dm->tdma_adj_type = 15;
2102                                 } else {
2103                                         halbtc8821a2ant_ps_tdma(btcoexist,
2104                                                                 NORMAL_EXEC,
2105                                                                 true, 15);
2106                                         coex_dm->tdma_adj_type = 15;
2107                                 }
2108                         } else {
2109                                 if (max_interval == 1) {
2110                                         halbtc8821a2ant_ps_tdma(btcoexist,
2111                                                                 NORMAL_EXEC,
2112                                                                 true, 9);
2113                                         coex_dm->tdma_adj_type = 9;
2114                                 } else if (max_interval == 2) {
2115                                         halbtc8821a2ant_ps_tdma(btcoexist,
2116                                                                 NORMAL_EXEC,
2117                                                                 true, 10);
2118                                         coex_dm->tdma_adj_type = 10;
2119                                 } else if (max_interval == 3) {
2120                                         halbtc8821a2ant_ps_tdma(btcoexist,
2121                                                                 NORMAL_EXEC,
2122                                                                 true, 11);
2123                                         coex_dm->tdma_adj_type = 11;
2124                                 } else {
2125                                         halbtc8821a2ant_ps_tdma(btcoexist,
2126                                                                 NORMAL_EXEC,
2127                                                                 true, 11);
2128                                         coex_dm->tdma_adj_type = 11;
2129                                 }
2130                         }
2131                 } else {
2132                         if (tx_pause) {
2133                                 if (max_interval == 1) {
2134                                         halbtc8821a2ant_ps_tdma(btcoexist,
2135                                                                 NORMAL_EXEC,
2136                                                                 true, 5);
2137                                         coex_dm->tdma_adj_type = 5;
2138                                 } else if (max_interval == 2) {
2139                                         halbtc8821a2ant_ps_tdma(btcoexist,
2140                                                                 NORMAL_EXEC,
2141                                                                 true, 6);
2142                                         coex_dm->tdma_adj_type = 6;
2143                                 } else if (max_interval == 3) {
2144                                         halbtc8821a2ant_ps_tdma(btcoexist,
2145                                                                 NORMAL_EXEC,
2146                                                                 true, 7);
2147                                         coex_dm->tdma_adj_type = 7;
2148                                 } else {
2149                                         halbtc8821a2ant_ps_tdma(btcoexist,
2150                                                                 NORMAL_EXEC,
2151                                                                 true, 7);
2152                                         coex_dm->tdma_adj_type = 7;
2153                                 }
2154                         } else {
2155                                 if (max_interval == 1) {
2156                                         halbtc8821a2ant_ps_tdma(btcoexist,
2157                                                                 NORMAL_EXEC,
2158                                                                 true, 1);
2159                                         coex_dm->tdma_adj_type = 1;
2160                                 } else if (max_interval == 2) {
2161                                         halbtc8821a2ant_ps_tdma(btcoexist,
2162                                                                 NORMAL_EXEC,
2163                                                                 true, 2);
2164                                         coex_dm->tdma_adj_type = 2;
2165                                 } else if (max_interval == 3) {
2166                                         halbtc8821a2ant_ps_tdma(btcoexist,
2167                                                                 NORMAL_EXEC,
2168                                                                 true, 3);
2169                                         coex_dm->tdma_adj_type = 3;
2170                                 } else {
2171                                         halbtc8821a2ant_ps_tdma(btcoexist,
2172                                                                 NORMAL_EXEC,
2173                                                                 true, 3);
2174                                         coex_dm->tdma_adj_type = 3;
2175                                 }
2176                         }
2177                 }
2178
2179                 up = 0;
2180                 dn = 0;
2181                 m = 1;
2182                 n = 3;
2183                 result = 0;
2184                 wait_count = 0;
2185         } else {
2186                 /* accquire the BT TRx retry count from BT_Info byte2 */
2187                 retry_count = coex_sta->bt_retry_cnt;
2188                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2189                             "[BTCoex], retry_count = %d\n", retry_count);
2190                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2191                             "[BTCoex], up = %d, dn = %d, m = %d, n = %d, wait_count = %d\n",
2192                             (int)up, (int)dn, (int)m, (int)n, (int)wait_count);
2193                 result = 0;
2194                 wait_count++;
2195
2196                 if (retry_count == 0) {
2197                         /* no retry in the last 2-second duration */
2198                         up++;
2199                         dn--;
2200
2201                         if (dn <= 0)
2202                                 dn = 0;
2203
2204                         if (up >= n) {
2205                                 /* if (retry count == 0) for 2*n seconds,
2206                                  * make WiFi duration wider
2207                                  */
2208                                 wait_count = 0;
2209                                 n = 3;
2210                                 up = 0;
2211                                 dn = 0;
2212                                 result = 1;
2213                                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2214                                             "[BTCoex], Increase wifi duration!!\n");
2215                         }
2216                 } else if (retry_count <= 3) {
2217                         /* <=3 retry in the last 2-second duration */
2218                         up--;
2219                         dn++;
2220
2221                         if (up <= 0)
2222                                 up = 0;
2223
2224                         if (dn == 2) {
2225                                 /* if retry count< 3 for 2*2 seconds,
2226                                  * shrink wifi duration
2227                                  */
2228                                 if (wait_count <= 2)
2229                                         m++; /* avoid bounce in two levels */
2230                                 else
2231                                         m = 1;
2232                                 /* m max value is 20, max time is 120 second,
2233                                  * recheck if adjust WiFi duration.
2234                                  */
2235                                 if (m >= 20)
2236                                         m = 20;
2237
2238                                 n = 3*m;
2239                                 up = 0;
2240                                 dn = 0;
2241                                 wait_count = 0;
2242                                 result = -1;
2243                                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2244                                             "[BTCoex], Decrease wifi duration for retryCounter<3!!\n");
2245                         }
2246                 } else {
2247                         /* retry count > 3, if retry count > 3 happens once,
2248                          * shrink WiFi duration
2249                          */
2250                         if (wait_count == 1)
2251                                 m++; /* avoid bounce in two levels */
2252                         else
2253                                 m = 1;
2254                         /* m max value is 20, max time is 120 second,
2255                          * recheck if adjust WiFi duration.
2256                          */
2257                         if (m >= 20)
2258                                 m = 20;
2259
2260                         n = 3*m;
2261                         up = 0;
2262                         dn = 0;
2263                         wait_count = 0;
2264                         result = -1;
2265                         btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2266                                     "[BTCoex], Decrease wifi duration for retryCounter>3!!\n");
2267                 }
2268
2269                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2270                             "[BTCoex], max Interval = %d\n", max_interval);
2271                 if (max_interval == 1)
2272                         btc8821a2_int1(btcoexist, tx_pause, result);
2273                 else if (max_interval == 2)
2274                         btc8821a2_int2(btcoexist, tx_pause, result);
2275                 else if (max_interval == 3)
2276                         btc8821a2_int3(btcoexist, tx_pause, result);
2277         }
2278
2279         /* if current PsTdma not match with the recorded one
2280          * (when scan, dhcp...), then we have to adjust it back to
2281          * the previous recorded one.
2282          */
2283         if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2284                 bool    scan = false, link = false, roam = false;
2285
2286                 btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2287                             "[BTCoex], PsTdma type dismatch!!!, cur_ps_tdma = %d, recordPsTdma = %d\n",
2288                             coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2289
2290                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2291                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2292                 btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2293
2294                 if (!scan && !link && !roam) {
2295                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2296                                                 coex_dm->tdma_adj_type);
2297                 } else {
2298                         btc_alg_dbg(ALGO_TRACE_FW_DETAIL,
2299                                     "[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n");
2300                 }
2301         }
2302
2303         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 0x6);
2304 }
2305
2306 /* SCO only or SCO+PAN(HS)*/
2307 static void halbtc8821a2ant_action_sco(struct btc_coexist *btcoexist)
2308 {
2309         u8      wifi_rssi_state, bt_rssi_state;
2310         u32 wifi_bw;
2311
2312         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2313                                                           15, 0);
2314         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2315
2316         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2317
2318         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2319                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2320         else
2321                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2322
2323         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2324
2325         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2326                 /* for SCO quality at 11b/g mode */
2327                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC,
2328                                            0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3);
2329         } else {
2330                 /* for SCO quality & wifi performance balance at 11n mode */
2331                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC,
2332                                            0x5aea5aea, 0x5aea5aea, 0xffff, 0x3);
2333         }
2334
2335         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2336                 /* fw mechanism
2337                  * halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2338                  */
2339
2340                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2341                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2342                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2343                                                 false, 0); /*for voice quality*/
2344                 } else {
2345                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2346                                                 false, 0); /*for voice quality*/
2347                 }
2348
2349                 /* sw mechanism */
2350                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2351                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2352                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2353                                               false, false);
2354                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2355                                               false, 0x18);
2356                 } else {
2357                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2358                                               false, false);
2359                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2360                                               false, 0x18);
2361                 }
2362         } else {
2363                 /* fw mechanism
2364                  * halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2365                  */
2366                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2367                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2368                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2369                                                 false, 0); /*for voice quality*/
2370                 } else {
2371                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2372                                                 false, 0); /*for voice quality*/
2373                 }
2374
2375                 /* sw mechanism */
2376                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2377                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2378                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2379                                               false, false);
2380                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2381                                               false, 0x18);
2382                 } else {
2383                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2384                                               false, false);
2385                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2386                                               false, 0x18);
2387                 }
2388         }
2389 }
2390
2391 static void halbtc8821a2ant_action_hid(struct btc_coexist *btcoexist)
2392 {
2393         u8      wifi_rssi_state, bt_rssi_state;
2394         u32     wifi_bw;
2395
2396         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist,
2397                                                           0, 2, 15, 0);
2398         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2399
2400         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2401
2402         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2403                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2404         else
2405                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2406
2407         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2408
2409         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2410                 /* for HID at 11b/g mode */
2411                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2412                                            0x5a5a5a5a, 0xffff, 0x3);
2413         } else {
2414                 /* for HID quality & wifi performance balance at 11n mode */
2415                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2416                                            0x5aea5aea, 0xffff, 0x3);
2417         }
2418
2419         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2420                 /* fw mechanism */
2421                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2422                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2423                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2424                                                 true, 9);
2425                 } else {
2426                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2427                                                 true, 13);
2428                 }
2429
2430                 /* sw mechanism */
2431                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2432                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2433                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2434                                               false, false);
2435                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2436                                               false, 0x18);
2437                 } else {
2438                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2439                                               false, false);
2440                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2441                                               false, 0x18);
2442                 }
2443         } else {
2444                 /* fw mechanism */
2445                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2446                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2447                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2448                                                 true, 9);
2449                 } else {
2450                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2451                                                 true, 13);
2452                 }
2453
2454                 /* sw mechanism */
2455                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2456                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2457                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2458                                               false, false);
2459                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2460                                               false, 0x18);
2461                 } else {
2462                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2463                                               false, false);
2464                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2465                                               false, 0x18);
2466                 }
2467         }
2468 }
2469
2470 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2471 static void halbtc8821a2ant_action_a2dp(struct btc_coexist *btcoexist)
2472 {
2473         u8              wifi_rssi_state, bt_rssi_state;
2474         u32             wifi_bw;
2475
2476         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2477                                                           15, 0);
2478         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2479
2480         /* fw dac swing is called in btc8821a2ant_tdma_dur_adj()
2481          * halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2482          */
2483
2484         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2485                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2486         else
2487                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2488
2489         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2490
2491         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2492                 /* fw mechanism */
2493                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2494                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2495                         btc8821a2ant_tdma_dur_adj(btcoexist, false, false, 1);
2496                 } else {
2497                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 1);
2498                 }
2499
2500                 /* sw mechanism */
2501                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2502                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2503                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2504                                               false, false);
2505                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2506                                               false, 0x18);
2507                 } else {
2508                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2509                                               false, false);
2510                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2511                                               false, 0x18);
2512                 }
2513         } else {
2514                 /* fw mechanism */
2515                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2516                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2517                         btc8821a2ant_tdma_dur_adj(btcoexist, false, false, 1);
2518                 } else {
2519                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 1);
2520                 }
2521
2522                 /* sw mechanism */
2523                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2524                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2525                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2526                                               false, false);
2527                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2528                                               false, 0x18);
2529                 } else {
2530                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2531                                               false, false);
2532                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2533                                               false, 0x18);
2534                 }
2535         }
2536 }
2537
2538 static void halbtc8821a2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2539 {
2540         u8              wifi_rssi_state, bt_rssi_state, bt_info_ext;
2541         u32             wifi_bw;
2542
2543         bt_info_ext = coex_sta->bt_info_ext;
2544         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2545                                                           15, 0);
2546         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2547
2548         /*fw dac swing is called in btc8821a2ant_tdma_dur_adj()
2549          *halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2550          */
2551
2552         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2553                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2554         else
2555                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2556
2557         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2558
2559         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2560                 /* fw mechanism */
2561                 if (bt_info_ext&BIT0) {
2562                         /*a2dp basic rate*/
2563                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 2);
2564                 } else {
2565                         /*a2dp edr rate*/
2566                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 1);
2567                 }
2568
2569                 /* sw mechanism */
2570                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2571                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2572                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2573                                               false, false);
2574                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2575                                               false, 0x18);
2576                 } else {
2577                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2578                                               false, false);
2579                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2580                                               false, 0x18);
2581                 }
2582         } else {
2583                 /* fw mechanism */
2584                 if (bt_info_ext&BIT0) {
2585                         /* a2dp basic rate */
2586                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 2);
2587                 } else {
2588                         /* a2dp edr rate */
2589                         btc8821a2ant_tdma_dur_adj(btcoexist, false, true, 1);
2590                 }
2591
2592                 /* sw mechanism */
2593                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2594                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2595                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2596                                               false, false);
2597                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2598                                               false, 0x18);
2599                 } else {
2600                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2601                                               false, false);
2602                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2603                                               false, 0x18);
2604                 }
2605         }
2606 }
2607
2608 static void halbtc8821a2ant_action_pan_edr(struct btc_coexist *btcoexist)
2609 {
2610         u8              wifi_rssi_state, bt_rssi_state;
2611         u32             wifi_bw;
2612
2613         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2614                                                           15, 0);
2615         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2616
2617         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2618
2619         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2620                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2621         else
2622                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2623
2624         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2625
2626         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2627                 /* for HID at 11b/g mode */
2628                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2629                                            0x5aff5aff, 0xffff, 0x3);
2630         } else {
2631                 /* for HID quality & wifi performance balance at 11n mode */
2632                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2633                                            0x5aff5aff, 0xffff, 0x3);
2634         }
2635
2636         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2637                 /* fw mechanism */
2638                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2639                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2640                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2641                                                 true, 1);
2642                 } else {
2643                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2644                                                 true, 5);
2645                 }
2646
2647                 /* sw mechanism */
2648                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2649                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2650                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2651                                               false, false);
2652                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2653                                               false, 0x18);
2654                 } else {
2655                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2656                                               false, false);
2657                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2658                                               false, 0x18);
2659                 }
2660         } else {
2661                 /* fw mechanism */
2662                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2663                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2664                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2665                                                 true, 1);
2666                 } else {
2667                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2668                                                 true, 5);
2669                 }
2670
2671                 /* sw mechanism */
2672                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2673                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2674                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2675                                               false, false);
2676                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2677                                               false, 0x18);
2678                 } else {
2679                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2680                                               false, false);
2681                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2682                                               false, 0x18);
2683                 }
2684         }
2685 }
2686
2687 /* PAN(HS) only */
2688 static void halbtc8821a2ant_action_pan_hs(struct btc_coexist *btcoexist)
2689 {
2690         u8              wifi_rssi_state, bt_rssi_state;
2691         u32             wifi_bw;
2692
2693         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist,
2694                                                           0, 2, 15, 0);
2695         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2696
2697         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2698
2699         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2700
2701         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2702                 /* fw mechanism */
2703                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2704                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2705                         halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
2706                                                    true);
2707                 } else {
2708                         halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
2709                                                    false);
2710                 }
2711                 halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2712
2713                 /* sw mechanism */
2714                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2715                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2716                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2717                                               false, false);
2718                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2719                                               false, 0x18);
2720                 } else {
2721                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2722                                               false, false);
2723                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2724                                               false, 0x18);
2725                 }
2726         } else {
2727                 /* fw mechanism */
2728                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2729                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2730                         halbtc8821a2ant_dec_bt_pwr(btcoexist,
2731                                                    NORMAL_EXEC, true);
2732                 } else {
2733                         halbtc8821a2ant_dec_bt_pwr(btcoexist,
2734                                                    NORMAL_EXEC, false);
2735                 }
2736
2737                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2738                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2739                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2740                                                 false, 1);
2741                 } else {
2742                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2743                                                 false, 1);
2744                 }
2745
2746                 /* sw mechanism */
2747                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2748                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2749                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2750                                               false, false);
2751                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2752                                               false, 0x18);
2753                 } else {
2754                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2755                                               false, false);
2756                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2757                                               false, 0x18);
2758                 }
2759         }
2760 }
2761
2762 /* PAN(EDR)+A2DP */
2763 static void halbtc8821a2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2764 {
2765         u8      wifi_rssi_state, bt_rssi_state, bt_info_ext;
2766         u32     wifi_bw;
2767
2768         bt_info_ext = coex_sta->bt_info_ext;
2769         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2770                                                           15, 0);
2771         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2772
2773         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2774
2775         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2776                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2777         else
2778                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2779
2780         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2781
2782         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2783                 /* for HID at 11b/g mode */
2784                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2785                                            0x5afa5afa, 0xffff, 0x3);
2786         } else {
2787                 /* for HID quality & wifi performance balance at 11n mode */
2788                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2789                                            0x5afa5afa, 0xffff, 0x3);
2790         }
2791
2792         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2793                 /* fw mechanism */
2794                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2795                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2796                         if (bt_info_ext&BIT0) {
2797                                 /* a2dp basic rate */
2798                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2799                                                           false, 3);
2800                         } else {
2801                                 /* a2dp edr rate */
2802                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2803                                                           false, 3);
2804                         }
2805                 } else {
2806                         if (bt_info_ext&BIT0) {
2807                                 /* a2dp basic rate */
2808                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2809                                                           true, 3);
2810                         } else {
2811                                 /* a2dp edr rate */
2812                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2813                                                           true, 3);
2814                         }
2815                 }
2816
2817                 /* sw mechanism */
2818                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2819                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2820                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2821                                               false, false);
2822                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2823                                               false, 0x18);
2824                 } else {
2825                         btc8821a2ant_sw_mech1(btcoexist, true, false,
2826                                               false, false);
2827                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2828                                               false, 0x18);
2829                 };
2830         } else {
2831                 /* fw mechanism */
2832                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2833                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2834                         if (bt_info_ext&BIT0) {
2835                                 /* a2dp basic rate */
2836                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2837                                                           false, 3);
2838                         } else {
2839                                 /* a2dp edr rate */
2840                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2841                                                           false, 3);
2842                         }
2843                 } else {
2844                         if (bt_info_ext&BIT0) {
2845                                 /* a2dp basic rate */
2846                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2847                                                           true, 3);
2848                         } else {
2849                                 /* a2dp edr rate */
2850                                 btc8821a2ant_tdma_dur_adj(btcoexist, false,
2851                                                           true, 3);
2852                         }
2853                 }
2854
2855                 /* sw mechanism */
2856                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2857                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2858                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2859                                               false, false);
2860                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2861                                               false, 0x18);
2862                 } else {
2863                         btc8821a2ant_sw_mech1(btcoexist, false, false,
2864                                               false, false);
2865                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2866                                               false, 0x18);
2867                 }
2868         }
2869 }
2870
2871 static void halbtc8821a2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2872 {
2873         u8      wifi_rssi_state, bt_rssi_state;
2874         u32     wifi_bw;
2875
2876         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
2877                                                           15, 0);
2878         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2879
2880         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2881
2882         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2883                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2884         else
2885                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2886
2887         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2888
2889         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2890                 /* for HID at 11b/g mode */
2891                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2892                                            0x5a5f5a5f, 0xffff, 0x3);
2893         } else {
2894                 /* for HID quality & wifi performance balance at 11n mode */
2895                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2896                                            0x5a5f5a5f, 0xffff, 0x3);
2897         }
2898
2899         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2900                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 3);
2901                 /* fw mechanism */
2902                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2903                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2904                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2905                                                 true, 10);
2906                 } else {
2907                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2908                                                 true, 14);
2909                 }
2910
2911                 /* sw mechanism */
2912                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2913                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2914                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2915                                               false, false);
2916                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2917                                               false, 0x18);
2918                 } else {
2919                         btc8821a2ant_sw_mech1(btcoexist, true, true,
2920                                               false, false);
2921                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2922                                               false, 0x18);
2923                 }
2924         } else {
2925                 halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2926                 /* fw mechanism */
2927                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2928                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2929                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2930                                                 true, 10);
2931                 } else {
2932                         halbtc8821a2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2933                                                 true, 14);
2934                 }
2935
2936                 /* sw mechanism */
2937                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2938                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2939                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2940                                               false, false);
2941                         btc8821a2ant_sw_mech2(btcoexist, true, false,
2942                                               false, 0x18);
2943                 } else {
2944                         btc8821a2ant_sw_mech1(btcoexist, false, true,
2945                                               false, false);
2946                         btc8821a2ant_sw_mech2(btcoexist, false, false,
2947                                               false, 0x18);
2948                 }
2949         }
2950 }
2951
2952 /* HID+A2DP+PAN(EDR) */
2953 static void btc8821a2ant_act_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2954 {
2955         u8      wifi_rssi_state, bt_rssi_state, bt_info_ext;
2956         u32     wifi_bw;
2957
2958         bt_info_ext = coex_sta->bt_info_ext;
2959         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist,
2960                                                           0, 2, 15, 0);
2961         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
2962
2963         halbtc8821a2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2964
2965         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
2966                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2967         else
2968                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2969
2970         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2971
2972         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
2973                 /* for HID at 11b/g mode */
2974                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2975                                            0x5a5a5a5a, 0xffff, 0x3);
2976         } else {
2977                 /* for HID quality & wifi performance balance at 11n mode */
2978                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
2979                                            0x5a5a5a5a, 0xffff, 0x3);
2980         }
2981
2982         if (BTC_WIFI_BW_HT40 == wifi_bw) {
2983                 /* fw mechanism */
2984                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2985                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2986                         if (bt_info_ext&BIT0) {
2987                                 /* a2dp basic rate */
2988                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
2989                                                           true, 3);
2990                         } else {
2991                                 /* a2dp edr rate */
2992                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
2993                                                           true, 3);
2994                         }
2995                 } else {
2996                         if (bt_info_ext&BIT0) {
2997                                 /* a2dp basic rate */
2998                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
2999                                                           true, 3);
3000                         } else {
3001                                 /* a2dp edr rate */
3002                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
3003                                                           true, 3);
3004                         }
3005                 }
3006
3007                 /* sw mechanism */
3008                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3009                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3010                         btc8821a2ant_sw_mech1(btcoexist, true, true,
3011                                               false, false);
3012                         btc8821a2ant_sw_mech2(btcoexist, true, false,
3013                                               false, 0x18);
3014                 } else {
3015                         btc8821a2ant_sw_mech1(btcoexist, true, true,
3016                                               false, false);
3017                         btc8821a2ant_sw_mech2(btcoexist, false, false,
3018                                               false, 0x18);
3019                 }
3020         } else {
3021                 /* fw mechanism */
3022                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3023                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3024                         if (bt_info_ext&BIT0) {
3025                                 /* a2dp basic rate */
3026                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
3027                                                           false, 3);
3028                         } else {
3029                                 /* a2dp edr rate */
3030                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
3031                                                           false, 3);
3032                         }
3033                 } else {
3034                         if (bt_info_ext&BIT0) {
3035                                 /* a2dp basic rate */
3036                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
3037                                                           true, 3);
3038                         } else {
3039                                 /* a2dp edr rate */
3040                                 btc8821a2ant_tdma_dur_adj(btcoexist, true,
3041                                                           true, 3);
3042                         }
3043                 }
3044
3045                 /* sw mechanism */
3046                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3047                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3048                         btc8821a2ant_sw_mech1(btcoexist, false, true,
3049                                               false, false);
3050                         btc8821a2ant_sw_mech2(btcoexist, true, false,
3051                                               false, 0x18);
3052                 } else {
3053                         btc8821a2ant_sw_mech1(btcoexist, false, true,
3054                                               false, false);
3055                         btc8821a2ant_sw_mech2(btcoexist, false, false,
3056                                               false, 0x18);
3057                 }
3058         }
3059 }
3060
3061 static void halbtc8821a2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
3062 {
3063         u8      wifi_rssi_state, bt_rssi_state, bt_info_ext;
3064         u32     wifi_bw;
3065
3066         bt_info_ext = coex_sta->bt_info_ext;
3067         wifi_rssi_state = halbtc8821a2ant_wifi_rssi_state(btcoexist, 0, 2,
3068                                                           15, 0);
3069         bt_rssi_state = halbtc8821a2ant_bt_rssi_state(2, 35, 0);
3070
3071         if (halbtc8821a2ant_need_to_dec_bt_pwr(btcoexist))
3072                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
3073         else
3074                 halbtc8821a2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
3075
3076         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3077
3078         if (BTC_WIFI_BW_LEGACY == wifi_bw) {
3079                 /* for HID at 11b/g mode */
3080                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3081                                            0x5f5b5f5b, 0xffffff, 0x3);
3082         } else {
3083                 /*for HID quality & wifi performance balance at 11n mode*/
3084                 halbtc8821a2ant_coex_table(btcoexist, NORMAL_EXEC, 0x55ff55ff,
3085                                            0x5f5b5f5b, 0xffffff, 0x3);
3086         }
3087
3088         if (BTC_WIFI_BW_HT40 == wifi_bw) {
3089                 /* fw mechanism */
3090                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3091                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3092                         if (bt_info_ext&BIT0) {
3093                                 /* a2dp basic rate */
3094                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3095                                                           true, true, 2);
3096                         } else {
3097                                 /* a2dp edr rate */
3098                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3099                                                           true, true, 2);
3100                         }
3101                 } else {
3102                         if (bt_info_ext&BIT0) {
3103                                 /* a2dp basic rate */
3104                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3105                                                           true, true, 2);
3106                         } else {
3107                                 /* a2dp edr rate */
3108                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3109                                                           true, true, 2);
3110                         }
3111                 }
3112
3113                 /* sw mechanism */
3114                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3115                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3116                         btc8821a2ant_sw_mech1(btcoexist, true, true,
3117                                               false, false);
3118                         btc8821a2ant_sw_mech2(btcoexist, true, false,
3119                                               false, 0x18);
3120                 } else {
3121                         btc8821a2ant_sw_mech1(btcoexist, true, true,
3122                                               false, false);
3123                         btc8821a2ant_sw_mech2(btcoexist, false, false,
3124                                               false, 0x18);
3125                 }
3126         } else {
3127                 /* fw mechanism */
3128                 if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
3129                     (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3130                         if (bt_info_ext&BIT0) {
3131                                 /* a2dp basic rate */
3132                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3133                                                           true, true, 2);
3134
3135                         } else {
3136                                 /* a2dp edr rate */
3137                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3138                                                           true, true, 2);
3139                         }
3140                 } else {
3141                         if (bt_info_ext&BIT0) {
3142                                 /*a2dp basic rate*/
3143                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3144                                                           true, true, 2);
3145                         } else {
3146                                 /*a2dp edr rate*/
3147                                 btc8821a2ant_tdma_dur_adj(btcoexist,
3148                                                           true, true, 2);
3149                         }
3150                 }
3151
3152                 /* sw mechanism */
3153                 if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
3154                     (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
3155                         btc8821a2ant_sw_mech1(btcoexist, false, true,
3156                                               false, false);
3157                         btc8821a2ant_sw_mech2(btcoexist, true, false,
3158                                               false, 0x18);
3159                 } else {
3160                         btc8821a2ant_sw_mech1(btcoexist, false, true,
3161                                               false, false);
3162                         btc8821a2ant_sw_mech2(btcoexist, false, false,
3163                                               false, 0x18);
3164                 }
3165         }
3166 }
3167
3168 static void halbtc8821a2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
3169 {
3170         bool    wifi_under_5g = false;
3171         u8      algorithm = 0;
3172
3173         if (btcoexist->manual_control) {
3174                 btc_alg_dbg(ALGO_TRACE,
3175                             "[BTCoex], Manual control!!!\n");
3176                 return;
3177         }
3178
3179         btcoexist->btc_get(btcoexist,
3180                 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3181
3182         if (wifi_under_5g) {
3183                 btc_alg_dbg(ALGO_TRACE,
3184                             "[BTCoex], RunCoexistMechanism(), run 5G coex setting!!<===\n");
3185                 halbtc8821a2ant_coex_under_5g(btcoexist);
3186                 return;
3187         }
3188
3189         algorithm = halbtc8821a2ant_action_algorithm(btcoexist);
3190         if (coex_sta->c2h_bt_inquiry_page &&
3191             (BT_8821A_2ANT_COEX_ALGO_PANHS != algorithm)) {
3192                 btc_alg_dbg(ALGO_TRACE,
3193                             "[BTCoex], BT is under inquiry/page scan !!\n");
3194                 halbtc8821a2ant_bt_inquiry_page(btcoexist);
3195                 return;
3196         }
3197
3198         coex_dm->cur_algorithm = algorithm;
3199         btc_alg_dbg(ALGO_TRACE,
3200                     "[BTCoex], Algorithm = %d\n", coex_dm->cur_algorithm);
3201
3202         if (halbtc8821a2ant_is_common_action(btcoexist)) {
3203                 btc_alg_dbg(ALGO_TRACE,
3204                             "[BTCoex], Action 2-Ant common\n");
3205                 coex_dm->reset_tdma_adjust = true;
3206         } else {
3207                 if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
3208                         btc_alg_dbg(ALGO_TRACE,
3209                                     "[BTCoex], pre_algorithm = %d, cur_algorithm = %d\n",
3210                                     coex_dm->pre_algorithm,
3211                                     coex_dm->cur_algorithm);
3212                         coex_dm->reset_tdma_adjust = true;
3213                 }
3214                 switch (coex_dm->cur_algorithm) {
3215                 case BT_8821A_2ANT_COEX_ALGO_SCO:
3216                         btc_alg_dbg(ALGO_TRACE,
3217                                     "[BTCoex], Action 2-Ant, algorithm = SCO\n");
3218                         halbtc8821a2ant_action_sco(btcoexist);
3219                         break;
3220                 case BT_8821A_2ANT_COEX_ALGO_HID:
3221                         btc_alg_dbg(ALGO_TRACE,
3222                                     "[BTCoex], Action 2-Ant, algorithm = HID\n");
3223                         halbtc8821a2ant_action_hid(btcoexist);
3224                         break;
3225                 case BT_8821A_2ANT_COEX_ALGO_A2DP:
3226                         btc_alg_dbg(ALGO_TRACE,
3227                                     "[BTCoex], Action 2-Ant, algorithm = A2DP\n");
3228                         halbtc8821a2ant_action_a2dp(btcoexist);
3229                         break;
3230                 case BT_8821A_2ANT_COEX_ALGO_A2DP_PANHS:
3231                         btc_alg_dbg(ALGO_TRACE,
3232                                     "[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS)\n");
3233                         halbtc8821a2ant_action_a2dp_pan_hs(btcoexist);
3234                         break;
3235                 case BT_8821A_2ANT_COEX_ALGO_PANEDR:
3236                         btc_alg_dbg(ALGO_TRACE,
3237                                     "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)\n");
3238                         halbtc8821a2ant_action_pan_edr(btcoexist);
3239                         break;
3240                 case BT_8821A_2ANT_COEX_ALGO_PANHS:
3241                         btc_alg_dbg(ALGO_TRACE,
3242                                     "[BTCoex], Action 2-Ant, algorithm = HS mode\n");
3243                         halbtc8821a2ant_action_pan_hs(btcoexist);
3244                         break;
3245                 case BT_8821A_2ANT_COEX_ALGO_PANEDR_A2DP:
3246                         btc_alg_dbg(ALGO_TRACE,
3247                                     "[BTCoex], Action 2-Ant, algorithm = PAN+A2DP\n");
3248                         halbtc8821a2ant_action_pan_edr_a2dp(btcoexist);
3249                         break;
3250                 case BT_8821A_2ANT_COEX_ALGO_PANEDR_HID:
3251                         btc_alg_dbg(ALGO_TRACE,
3252                                     "[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID\n");
3253                         halbtc8821a2ant_action_pan_edr_hid(btcoexist);
3254                         break;
3255                 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
3256                         btc_alg_dbg(ALGO_TRACE,
3257                                     "[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN\n");
3258                         btc8821a2ant_act_hid_a2dp_pan_edr(btcoexist);
3259                         break;
3260                 case BT_8821A_2ANT_COEX_ALGO_HID_A2DP:
3261                         btc_alg_dbg(ALGO_TRACE,
3262                                     "[BTCoex], Action 2-Ant, algorithm = HID+A2DP\n");
3263                         halbtc8821a2ant_action_hid_a2dp(btcoexist);
3264                         break;
3265                 default:
3266                         btc_alg_dbg(ALGO_TRACE,
3267                                     "[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n");
3268                         halbtc8821a2ant_coex_all_off(btcoexist);
3269                         break;
3270                 }
3271                 coex_dm->pre_algorithm = coex_dm->cur_algorithm;
3272         }
3273 }
3274
3275 /*============================================================
3276  *work around function start with wa_halbtc8821a2ant_
3277  *============================================================
3278  *============================================================
3279  * extern function start with EXhalbtc8821a2ant_
3280  *============================================================
3281  */
3282 void ex_halbtc8821a2ant_init_hwconfig(struct btc_coexist *btcoexist)
3283 {
3284         u8 u1tmp = 0;
3285
3286         btc_iface_dbg(INTF_INIT,
3287                       "[BTCoex], 2Ant Init HW Config!!\n");
3288
3289         /* backup rf 0x1e value */
3290         coex_dm->bt_rf0x1e_backup =
3291                 btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff);
3292
3293         /* 0x790[5:0] = 0x5 */
3294         u1tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3295         u1tmp &= 0xc0;
3296         u1tmp |= 0x5;
3297         btcoexist->btc_write_1byte(btcoexist, 0x790, u1tmp);
3298
3299         /*Antenna config */
3300         halbtc8821a2ant_set_ant_path(btcoexist,
3301                                      BTC_ANT_WIFI_AT_MAIN, true, false);
3302
3303         /* PTA parameter */
3304         halbtc8821a2ant_coex_table(btcoexist,
3305                                    FORCE_EXEC, 0x55555555, 0x55555555,
3306                                    0xffff, 0x3);
3307
3308         /* Enable counter statistics */
3309         /*0x76e[3] = 1, WLAN_Act control by PTA*/
3310         btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
3311         btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3312         btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3313 }
3314
3315 void
3316 ex_halbtc8821a2ant_init_coex_dm(
3317         struct btc_coexist *btcoexist
3318         )
3319 {
3320         btc_iface_dbg(INTF_INIT,
3321                       "[BTCoex], Coex Mechanism Init!!\n");
3322
3323         halbtc8821a2ant_init_coex_dm(btcoexist);
3324 }
3325
3326 void
3327 ex_halbtc8821a2ant_display_coex_info(
3328         struct btc_coexist *btcoexist
3329         )
3330 {
3331         struct btc_board_info *board_info = &btcoexist->board_info;
3332         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3333         struct rtl_priv *rtlpriv = btcoexist->adapter;
3334         u8 u1tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3335         u32 u4tmp[4];
3336         bool roam = false, scan = false, link = false, wifi_under_5g = false;
3337         bool bt_hs_on = false, wifi_busy = false;
3338         long wifi_rssi = 0, bt_hs_rssi = 0;
3339         u32 wifi_bw, wifi_traffic_dir;
3340         u8 wifi_dot_11_chnl, wifi_hs_chnl;
3341         u32 fw_ver = 0, bt_patch_ver = 0;
3342
3343         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3344                    "\r\n ============[BT Coexist info]============");
3345
3346         if (!board_info->bt_exist) {
3347                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n BT not exists !!!");
3348                 return;
3349         }
3350
3351         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3352                    "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:",
3353                    board_info->pg_ant_num, board_info->btdm_ant_num);
3354
3355         if (btcoexist->manual_control) {
3356                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3357                            "\r\n %-35s", "[Action Manual control]!!");
3358         }
3359
3360         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3361                    "\r\n %-35s = %s / %d", "BT stack/ hci ext ver",
3362                    ((stack_info->profile_notified) ? "Yes" : "No"),
3363                    stack_info->hci_version);
3364
3365         btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3366         btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3367         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3368                    "\r\n %-35s = %d_%d/ 0x%x/ 0x%x(%d)",
3369                    "CoexVer/ FwVer/ PatchVer",
3370                    glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
3371                    fw_ver, bt_patch_ver, bt_patch_ver);
3372
3373         btcoexist->btc_get(btcoexist,
3374                 BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3375         btcoexist->btc_get(btcoexist,
3376                 BTC_GET_U1_WIFI_DOT11_CHNL, &wifi_dot_11_chnl);
3377         btcoexist->btc_get(btcoexist,
3378                 BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3379         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3380                    "\r\n %-35s = %d / %d(%d)",
3381                    "Dot11 channel / HsMode(HsChnl)",
3382                    wifi_dot_11_chnl, bt_hs_on, wifi_hs_chnl);
3383
3384         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3385                    "\r\n %-35s = %3ph ",
3386                    "H2C Wifi inform bt chnl Info",
3387                    coex_dm->wifi_chnl_info);
3388
3389         btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3390         btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3391         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3392                    "\r\n %-35s = %ld/ %ld", "Wifi rssi/ HS rssi",
3393                    wifi_rssi, bt_hs_rssi);
3394
3395         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3396         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3397         btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3398         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3399                    "\r\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan",
3400                    link, roam, scan);
3401
3402         btcoexist->btc_get(btcoexist,
3403                 BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3404         btcoexist->btc_get(btcoexist,
3405                 BTC_GET_U4_WIFI_BW, &wifi_bw);
3406         btcoexist->btc_get(btcoexist,
3407                 BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3408         btcoexist->btc_get(btcoexist,
3409                 BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifi_traffic_dir);
3410         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3411                    "\r\n %-35s = %s / %s/ %s ", "Wifi status",
3412                    (wifi_under_5g ? "5G" : "2.4G"),
3413                    ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3414                     (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3415                    ((!wifi_busy) ? "idle" :
3416                     ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3417                      "uplink" : "downlink")));
3418
3419         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3420                    "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]",
3421                    ((coex_sta->c2h_bt_inquiry_page) ? ("inquiry/page scan") :
3422                     ((BT_8821A_2ANT_BT_STATUS_IDLE == coex_dm->bt_status)
3423                      ? "idle" : ((BT_8821A_2ANT_BT_STATUS_CON_IDLE ==
3424                      coex_dm->bt_status) ? "connected-idle" : "busy"))),
3425                     coex_sta->bt_rssi, coex_sta->bt_retry_cnt);
3426
3427         if (stack_info->profile_notified) {
3428                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3429                            "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
3430                            stack_info->sco_exist, stack_info->hid_exist,
3431                            stack_info->pan_exist, stack_info->a2dp_exist);
3432
3433                 btcoexist->btc_disp_dbg_msg(btcoexist,
3434                                             BTC_DBG_DISP_BT_LINK_INFO);
3435         }
3436
3437         bt_info_ext = coex_sta->bt_info_ext;
3438         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s",
3439                    "BT Info A2DP rate",
3440                    (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3441
3442         for (i = 0; i < BT_INFO_SRC_8821A_2ANT_MAX; i++) {
3443                 if (coex_sta->bt_info_c2h_cnt[i]) {
3444                         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3445                                    "\r\n %-35s = %7ph(%d)",
3446                                    glbt_info_src_8821a_2ant[i],
3447                                    coex_sta->bt_info_c2h[i],
3448                                    coex_sta->bt_info_c2h_cnt[i]);
3449                 }
3450         }
3451
3452         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %s/%s",
3453                    "PS state, IPS/LPS",
3454                    ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3455                    ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3456         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3457
3458         /* Sw mechanism*/
3459         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3460                    "============[Sw mechanism]============");
3461         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3462                    "\r\n %-35s = %d/ %d/ %d/ %d ",
3463                    "SM1[ShRf/ LpRA/ LimDig/ btLna]",
3464                    coex_dm->cur_rf_rx_lpf_shrink, coex_dm->cur_low_penalty_ra,
3465                    coex_dm->limited_dig, coex_dm->cur_bt_lna_constrain);
3466         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3467                    "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3468                    "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3469                    coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3470                    coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3471
3472         /* Fw mechanism*/
3473         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s",
3474                    "============[Fw mechanism]============");
3475
3476         if (!btcoexist->manual_control) {
3477                 ps_tdma_case = coex_dm->cur_ps_tdma;
3478                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3479                            "\r\n %-35s = %5ph case-%d",
3480                            "PS TDMA",
3481                            coex_dm->ps_tdma_para, ps_tdma_case);
3482
3483                 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3484                            "\r\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct",
3485                            coex_dm->cur_dec_bt_pwr,
3486                            coex_dm->cur_ignore_wlan_act);
3487         }
3488
3489         /* Hw setting*/
3490         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3491                    "\r\n %-35s", "============[Hw setting]============");
3492
3493         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
3494                    "\r\n %-35s = 0x%x", "RF-A, 0x1e initVal",
3495                    coex_dm->bt_rf0x1e_backup);
3496
3497         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3498         u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3499         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x ",
3500                    "0x778 (W_Act)/ 0x6cc (CoTab Sel)",
3501                    u1tmp[0], u1tmp[1]);
3502
3503         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x8db);
3504         u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xc5b);
3505         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3506                    "0x8db(ADC)/0xc5b[29:25](DAC)",
3507                    ((u1tmp[0]&0x60)>>5), ((u1tmp[1]&0x3e)>>1));
3508
3509         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xcb4);
3510         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3511                    "0xcb4[7:0](ctrl)/ 0xcb4[29:28](val)",
3512                    u4tmp[0]&0xff, ((u4tmp[0]&0x30000000)>>28));
3513
3514         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3515         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3516         u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x974);
3517         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3518                    "0x40/ 0x4c[24:23]/ 0x974",
3519                    u1tmp[0], ((u4tmp[0]&0x01800000)>>23), u4tmp[1]);
3520
3521         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3522         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3523         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3524                    "0x550(bcn ctrl)/0x522",
3525                    u4tmp[0], u1tmp[0]);
3526
3527         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3528         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa0a);
3529         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3530                    "0xc50(DIG)/0xa0a(CCK-TH)",
3531                    u4tmp[0], u1tmp[0]);
3532
3533         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48);
3534         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3535         u1tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3536         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x",
3537                    "OFDM-FA/ CCK-FA",
3538                    u4tmp[0], (u1tmp[0]<<8) + u1tmp[1]);
3539
3540         u4tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3541         u4tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3542         u4tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3543         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3544                    "0x6c0/0x6c4/0x6c8",
3545                    u4tmp[0], u4tmp[1], u4tmp[2]);
3546
3547         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3548                    "0x770 (hi-pri Rx/Tx)",
3549                    coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3550         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = %d/ %d",
3551                    "0x774(low-pri Rx/Tx)",
3552                    coex_sta->low_priority_rx, coex_sta->low_priority_tx);
3553
3554         /* Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang*/
3555         u1tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x41b);
3556         RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "\r\n %-35s = 0x%x",
3557                    "0x41b (mgntQ hang chk == 0xf)",
3558                    u1tmp[0]);
3559
3560         btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS);
3561 }
3562
3563 void ex_halbtc8821a2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3564 {
3565         if (BTC_IPS_ENTER == type) {
3566                 btc_iface_dbg(INTF_NOTIFY,
3567                               "[BTCoex], IPS ENTER notify\n");
3568                 coex_sta->under_ips = true;
3569                 halbtc8821a2ant_coex_all_off(btcoexist);
3570         } else if (BTC_IPS_LEAVE == type) {
3571                 btc_iface_dbg(INTF_NOTIFY,
3572                               "[BTCoex], IPS LEAVE notify\n");
3573                 coex_sta->under_ips = false;
3574                 /*halbtc8821a2ant_init_coex_dm(btcoexist);*/
3575         }
3576 }
3577
3578 void ex_halbtc8821a2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3579 {
3580         if (BTC_LPS_ENABLE == type) {
3581                 btc_iface_dbg(INTF_NOTIFY,
3582                               "[BTCoex], LPS ENABLE notify\n");
3583                 coex_sta->under_lps = true;
3584         } else if (BTC_LPS_DISABLE == type) {
3585                 btc_iface_dbg(INTF_NOTIFY,
3586                               "[BTCoex], LPS DISABLE notify\n");
3587                 coex_sta->under_lps = false;
3588         }
3589 }
3590
3591 void ex_halbtc8821a2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3592 {
3593         if (BTC_SCAN_START == type) {
3594                 btc_iface_dbg(INTF_NOTIFY,
3595                               "[BTCoex], SCAN START notify\n");
3596         } else if (BTC_SCAN_FINISH == type) {
3597                 btc_iface_dbg(INTF_NOTIFY,
3598                               "[BTCoex], SCAN FINISH notify\n");
3599         }
3600 }
3601
3602 void ex_halbtc8821a2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3603 {
3604         if (BTC_ASSOCIATE_START == type) {
3605                 btc_iface_dbg(INTF_NOTIFY,
3606                               "[BTCoex], CONNECT START notify\n");
3607         } else if (BTC_ASSOCIATE_FINISH == type) {
3608                 btc_iface_dbg(INTF_NOTIFY,
3609                               "[BTCoex], CONNECT FINISH notify\n");
3610         }
3611 }
3612
3613 void ex_halbtc8821a2ant_media_status_notify(struct btc_coexist *btcoexist,
3614                                             u8 type)
3615 {
3616         u8      h2c_parameter[3] = {0};
3617         u32     wifi_bw;
3618         u8      wifi_central_chnl;
3619
3620         if (BTC_MEDIA_CONNECT == type) {
3621                 btc_iface_dbg(INTF_NOTIFY,
3622                               "[BTCoex], MEDIA connect notify\n");
3623         } else {
3624                 btc_iface_dbg(INTF_NOTIFY,
3625                               "[BTCoex], MEDIA disconnect notify\n");
3626         }
3627
3628         /* only 2.4G we need to inform bt the chnl mask*/
3629         btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL,
3630                            &wifi_central_chnl);
3631         if ((BTC_MEDIA_CONNECT == type) &&
3632             (wifi_central_chnl <= 14)) {
3633                 h2c_parameter[0] = 0x1;
3634                 h2c_parameter[1] = wifi_central_chnl;
3635                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3636                 if (BTC_WIFI_BW_HT40 == wifi_bw)
3637                         h2c_parameter[2] = 0x30;
3638                 else
3639                         h2c_parameter[2] = 0x20;
3640         }
3641
3642         coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3643         coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3644         coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3645
3646         btc_alg_dbg(ALGO_TRACE_FW_EXEC,
3647                     "[BTCoex], FW write 0x66 = 0x%x\n",
3648                     h2c_parameter[0] << 16 |
3649                     h2c_parameter[1] << 8 |
3650                     h2c_parameter[2]);
3651
3652         btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3653 }
3654
3655 void ex_halbtc8821a2ant_special_packet_notify(struct btc_coexist *btcoexist,
3656                                               u8 type) {
3657         if (type == BTC_PACKET_DHCP) {
3658                 btc_iface_dbg(INTF_NOTIFY,
3659                               "[BTCoex], DHCP Packet notify\n");
3660         }
3661 }
3662
3663 void ex_halbtc8821a2ant_bt_info_notify(struct btc_coexist *btcoexist,
3664                                        u8 *tmp_buf, u8 length)
3665 {
3666         u8              bt_info = 0;
3667         u8              i, rsp_source = 0;
3668         static u32      set_bt_lna_cnt, set_bt_psd_mode;
3669         bool            bt_busy = false, limited_dig = false;
3670         bool            wifi_connected = false, bt_hs_on = false;
3671
3672         coex_sta->c2h_bt_info_req_sent = false;
3673
3674         rsp_source = tmp_buf[0]&0xf;
3675         if (rsp_source >= BT_INFO_SRC_8821A_2ANT_MAX)
3676                 rsp_source = BT_INFO_SRC_8821A_2ANT_WIFI_FW;
3677         coex_sta->bt_info_c2h_cnt[rsp_source]++;
3678
3679         btc_iface_dbg(INTF_NOTIFY,
3680                       "[BTCoex], Bt info[%d], length = %d, hex data = [",
3681                       rsp_source, length);
3682         for (i = 0; i < length; i++) {
3683                 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
3684                 if (i == 1)
3685                         bt_info = tmp_buf[i];
3686                 if (i == length-1) {
3687                         btc_iface_dbg(INTF_NOTIFY,
3688                                       "0x%02x]\n", tmp_buf[i]);
3689                 } else {
3690                         btc_iface_dbg(INTF_NOTIFY,
3691                                       "0x%02x, ", tmp_buf[i]);
3692                 }
3693         }
3694
3695         if (BT_INFO_SRC_8821A_2ANT_WIFI_FW != rsp_source) {
3696                 coex_sta->bt_retry_cnt =        /* [3:0]*/
3697                         coex_sta->bt_info_c2h[rsp_source][2]&0xf;
3698
3699                 coex_sta->bt_rssi =
3700                         coex_sta->bt_info_c2h[rsp_source][3]*2+10;
3701
3702                 coex_sta->bt_info_ext =
3703                         coex_sta->bt_info_c2h[rsp_source][4];
3704
3705                 /* Here we need to resend some wifi info to BT*/
3706                 /* because bt is reset and loss of the info.*/
3707                 if ((coex_sta->bt_info_ext & BIT1)) {
3708                         btcoexist->btc_get(btcoexist,
3709                                 BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
3710                         if (wifi_connected) {
3711                                 ex_halbtc8821a2ant_media_status_notify(btcoexist,
3712                                         BTC_MEDIA_CONNECT);
3713                         } else {
3714                                 ex_halbtc8821a2ant_media_status_notify(btcoexist,
3715                                         BTC_MEDIA_DISCONNECT);
3716                         }
3717
3718                         set_bt_psd_mode = 0;
3719                 }
3720                 if (set_bt_psd_mode <= 3) {
3721                         halbtc8821a2ant_set_bt_psd_mode(btcoexist, FORCE_EXEC,
3722                                                         0x0); /*fix CH-BW mode*/
3723                         set_bt_psd_mode++;
3724                 }
3725
3726                 if (coex_dm->cur_bt_lna_constrain) {
3727                         if (!(coex_sta->bt_info_ext & BIT2)) {
3728                                 if (set_bt_lna_cnt <= 3) {
3729                                         btc8821a2_set_bt_lna_const(btcoexist,
3730                                                                    FORCE_EXEC,
3731                                                                    true);
3732                                         set_bt_lna_cnt++;
3733                                 }
3734                         }
3735                 } else {
3736                         set_bt_lna_cnt = 0;
3737                 }
3738
3739                 if ((coex_sta->bt_info_ext & BIT3)) {
3740                         halbtc8821a2ant_ignore_wlan_act(btcoexist,
3741                                                         FORCE_EXEC, false);
3742                 } else {
3743                         /* BT already NOT ignore Wlan active, do nothing here.*/
3744                 }
3745
3746                 if ((coex_sta->bt_info_ext & BIT4)) {
3747                         /* BT auto report already enabled, do nothing*/
3748                 } else {
3749                         halbtc8821a2ant_bt_auto_report(btcoexist,
3750                                                        FORCE_EXEC, true);
3751                 }
3752         }
3753
3754         btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3755         /* check BIT2 first ==> check if bt is under inquiry or page scan*/
3756         if (bt_info & BT_INFO_8821A_2ANT_B_INQ_PAGE) {
3757                 coex_sta->c2h_bt_inquiry_page = true;
3758                 coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_NON_IDLE;
3759         } else {
3760                 coex_sta->c2h_bt_inquiry_page = false;
3761                 if (bt_info == 0x1) {
3762                         /* connection exists but not busy*/
3763                         coex_sta->bt_link_exist = true;
3764                         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_CON_IDLE;
3765                 } else if (bt_info & BT_INFO_8821A_2ANT_B_CONNECTION) {
3766                         /* connection exists and some link is busy*/
3767                         coex_sta->bt_link_exist = true;
3768                         if (bt_info & BT_INFO_8821A_2ANT_B_FTP)
3769                                 coex_sta->pan_exist = true;
3770                         else
3771                                 coex_sta->pan_exist = false;
3772                         if (bt_info & BT_INFO_8821A_2ANT_B_A2DP)
3773                                 coex_sta->a2dp_exist = true;
3774                         else
3775                                 coex_sta->a2dp_exist = false;
3776                         if (bt_info & BT_INFO_8821A_2ANT_B_HID)
3777                                 coex_sta->hid_exist = true;
3778                         else
3779                                 coex_sta->hid_exist = false;
3780                         if (bt_info & BT_INFO_8821A_2ANT_B_SCO_ESCO)
3781                                 coex_sta->sco_exist = true;
3782                         else
3783                                 coex_sta->sco_exist = false;
3784                         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_NON_IDLE;
3785                 } else {
3786                         coex_sta->bt_link_exist = false;
3787                         coex_sta->pan_exist = false;
3788                         coex_sta->a2dp_exist = false;
3789                         coex_sta->hid_exist = false;
3790                         coex_sta->sco_exist = false;
3791                         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_IDLE;
3792                 }
3793
3794                 if (bt_hs_on)
3795                         coex_dm->bt_status = BT_8821A_2ANT_BT_STATUS_NON_IDLE;
3796         }
3797
3798         if (BT_8821A_2ANT_BT_STATUS_NON_IDLE == coex_dm->bt_status)
3799                 bt_busy = true;
3800         else
3801                 bt_busy = false;
3802         btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3803
3804         if (BT_8821A_2ANT_BT_STATUS_IDLE != coex_dm->bt_status)
3805                 limited_dig = true;
3806         else
3807                 limited_dig = false;
3808         coex_dm->limited_dig = limited_dig;
3809         btcoexist->btc_set(btcoexist,
3810                 BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3811
3812         halbtc8821a2ant_run_coexist_mechanism(btcoexist);
3813 }
3814
3815 void ex_halbtc8821a2ant_halt_notify(struct btc_coexist *btcoexist)
3816 {
3817         btc_iface_dbg(INTF_NOTIFY,
3818                       "[BTCoex], Halt notify\n");
3819
3820         halbtc8821a2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3821         ex_halbtc8821a2ant_media_status_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3822 }
3823
3824 void ex_halbtc8821a2ant_periodical(struct btc_coexist *btcoexist)
3825 {
3826         static u8       dis_ver_info_cnt;
3827         u32             fw_ver = 0, bt_patch_ver = 0;
3828         struct btc_board_info *board_info = &btcoexist->board_info;
3829         struct btc_stack_info *stack_info = &btcoexist->stack_info;
3830
3831         btc_alg_dbg(ALGO_TRACE,
3832                     "[BTCoex], ==========================Periodical===========================\n");
3833
3834         if (dis_ver_info_cnt <= 5) {
3835                 dis_ver_info_cnt += 1;
3836                 btc_iface_dbg(INTF_INIT,
3837                               "[BTCoex], ****************************************************************\n");
3838                 btc_iface_dbg(INTF_INIT,
3839                               "[BTCoex], Ant PG Num/ Ant Mech/ Ant Pos = %d/ %d/ %d\n",
3840                               board_info->pg_ant_num,
3841                               board_info->btdm_ant_num,
3842                               board_info->btdm_ant_pos);
3843                 btc_iface_dbg(INTF_INIT,
3844                               "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3845                               stack_info->profile_notified ? "Yes" : "No",
3846                               stack_info->hci_version);
3847                 btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3848                                    &bt_patch_ver);
3849                 btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3850                 btc_iface_dbg(INTF_INIT,
3851                               "[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n",
3852                               glcoex_ver_date_8821a_2ant, glcoex_ver_8821a_2ant,
3853                               fw_ver, bt_patch_ver, bt_patch_ver);
3854                 btc_iface_dbg(INTF_INIT,
3855                               "[BTCoex], ****************************************************************\n");
3856         }
3857
3858         halbtc8821a2ant_query_bt_info(btcoexist);
3859         halbtc8821a2ant_monitor_bt_ctr(btcoexist);
3860         btc8821a2ant_mon_bt_en_dis(btcoexist);
3861 }