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