LXR linux/drivers/net/wireless/rtlwifi/btcoexist/halbtc8723b2ant.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 * Description:
  27 *
  28 * This file is for RTL8723B Co-exist mechanism
  29 *
  30 * History
  31 * 2012/11/15 Cosa first check in.
  32 *
  33 **************************************************************/
  34/**************************************************************
  35 * include files
  36 **************************************************************/
  37#include "halbt_precomp.h"
  38/**************************************************************
  39 * Global variables, these are static variables
  40 **************************************************************/
  41static struct coex_dm_8723b_2ant glcoex_dm_8723b_2ant;
  42static struct coex_dm_8723b_2ant *coex_dm = &glcoex_dm_8723b_2ant;
  43static struct coex_sta_8723b_2ant glcoex_sta_8723b_2ant;
  44static struct coex_sta_8723b_2ant *coex_sta = &glcoex_sta_8723b_2ant;
  45
  46static const char *const glbt_info_src_8723b_2ant[] = {
  47        "BT Info[wifi fw]",
  48        "BT Info[bt rsp]",
  49        "BT Info[bt auto report]",
  50};
  51
  52static u32 glcoex_ver_date_8723b_2ant = 20130731;
  53static u32 glcoex_ver_8723b_2ant = 0x3b;
  54
  55/**************************************************************
  56 * local function proto type if needed
  57 **************************************************************/
  58/**************************************************************
  59 * local function start with btc8723b2ant_
  60 **************************************************************/
  61static u8 btc8723b2ant_bt_rssi_state(u8 level_num, u8 rssi_thresh,
  62                                     u8 rssi_thresh1)
  63{
  64        s32 bt_rssi = 0;
  65        u8 bt_rssi_state = coex_sta->pre_bt_rssi_state;
  66
  67        bt_rssi = coex_sta->bt_rssi;
  68
  69        if (level_num == 2) {
  70                if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
  71                    (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
  72                        if (bt_rssi >= rssi_thresh +
  73                                       BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
  74                                bt_rssi_state = BTC_RSSI_STATE_HIGH;
  75                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
  76                                          "[BTCoex], BT Rssi state "
  77                                          "switch to High\n");
  78                        } else {
  79                                bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
  80                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
  81                                          "[BTCoex], BT Rssi state "
  82                                          "stay at Low\n");
  83                        }
  84                } else {
  85                        if (bt_rssi < rssi_thresh) {
  86                                bt_rssi_state = BTC_RSSI_STATE_LOW;
  87                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
  88                                          "[BTCoex], BT Rssi state "
  89                                          "switch to Low\n");
  90                        } else {
  91                                bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
  92                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
  93                                          "[BTCoex], BT Rssi state "
  94                                          "stay at High\n");
  95                        }
  96                }
  97        } else if (level_num == 3) {
  98                if (rssi_thresh > rssi_thresh1) {
  99                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 100                                  "[BTCoex], BT Rssi thresh error!!\n");
 101                        return coex_sta->pre_bt_rssi_state;
 102                }
 103
 104                if ((coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
 105                    (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
 106                        if (bt_rssi >= rssi_thresh +
 107                                       BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 108                                bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
 109                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 110                                          "[BTCoex], BT Rssi state "
 111                                          "switch to Medium\n");
 112                        } else {
 113                                bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 114                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 115                                          "[BTCoex], BT Rssi state "
 116                                          "stay at Low\n");
 117                        }
 118                } else if ((coex_sta->pre_bt_rssi_state ==
 119                                                BTC_RSSI_STATE_MEDIUM) ||
 120                           (coex_sta->pre_bt_rssi_state ==
 121                                                BTC_RSSI_STATE_STAY_MEDIUM)) {
 122                        if (bt_rssi >= rssi_thresh1 +
 123                                       BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 124                                bt_rssi_state = BTC_RSSI_STATE_HIGH;
 125                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 126                                          "[BTCoex], BT Rssi state "
 127                                          "switch to High\n");
 128                        } else if (bt_rssi < rssi_thresh) {
 129                                bt_rssi_state = BTC_RSSI_STATE_LOW;
 130                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 131                                          "[BTCoex], BT Rssi state "
 132                                          "switch to Low\n");
 133                        } else {
 134                                bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 135                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 136                                          "[BTCoex], BT Rssi state "
 137                                          "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 "
 144                                          "switch to Medium\n");
 145                        } else {
 146                                bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 147                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE,
 148                                          "[BTCoex], BT Rssi state "
 149                                          "stay at High\n");
 150                        }
 151                }
 152        }
 153
 154        coex_sta->pre_bt_rssi_state = bt_rssi_state;
 155
 156        return bt_rssi_state;
 157}
 158
 159static u8 btc8723b2ant_wifi_rssi_state(struct btc_coexist *btcoexist,
 160                                       u8 index, u8 level_num,
 161                                       u8 rssi_thresh, u8 rssi_thresh1)
 162{
 163        s32 wifi_rssi = 0;
 164        u8 wifi_rssi_state = coex_sta->pre_wifi_rssi_state[index];
 165
 166        btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
 167
 168        if (level_num == 2) {
 169                if ((coex_sta->pre_wifi_rssi_state[index] ==
 170                                                BTC_RSSI_STATE_LOW) ||
 171                    (coex_sta->pre_wifi_rssi_state[index] ==
 172                                                BTC_RSSI_STATE_STAY_LOW)) {
 173                        if (wifi_rssi >= rssi_thresh +
 174                                         BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 175                                wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 176                                BTC_PRINT(BTC_MSG_ALGORITHM,
 177                                          ALGO_WIFI_RSSI_STATE,
 178                                          "[BTCoex], wifi RSSI state "
 179                                          "switch to High\n");
 180                        } else {
 181                                wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 182                                BTC_PRINT(BTC_MSG_ALGORITHM,
 183                                          ALGO_WIFI_RSSI_STATE,
 184                                          "[BTCoex], wifi RSSI state "
 185                                          "stay at Low\n");
 186                        }
 187                } else {
 188                        if (wifi_rssi < rssi_thresh) {
 189                                wifi_rssi_state = BTC_RSSI_STATE_LOW;
 190                                BTC_PRINT(BTC_MSG_ALGORITHM,
 191                                          ALGO_WIFI_RSSI_STATE,
 192                                          "[BTCoex], wifi RSSI state "
 193                                          "switch to Low\n");
 194                        } else {
 195                                wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 196                                BTC_PRINT(BTC_MSG_ALGORITHM,
 197                                          ALGO_WIFI_RSSI_STATE,
 198                                          "[BTCoex], wifi RSSI state "
 199                                          "stay at High\n");
 200                        }
 201                }
 202        } else if (level_num == 3) {
 203                if (rssi_thresh > rssi_thresh1) {
 204                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE,
 205                                  "[BTCoex], wifi RSSI thresh error!!\n");
 206                        return coex_sta->pre_wifi_rssi_state[index];
 207                }
 208
 209                if ((coex_sta->pre_wifi_rssi_state[index] ==
 210                                                BTC_RSSI_STATE_LOW) ||
 211                    (coex_sta->pre_wifi_rssi_state[index] ==
 212                                                BTC_RSSI_STATE_STAY_LOW)) {
 213                        if (wifi_rssi >= rssi_thresh +
 214                                        BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 215                                wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 216                                BTC_PRINT(BTC_MSG_ALGORITHM,
 217                                          ALGO_WIFI_RSSI_STATE,
 218                                          "[BTCoex], wifi RSSI state "
 219                                          "switch to Medium\n");
 220                        } else {
 221                                wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
 222                                BTC_PRINT(BTC_MSG_ALGORITHM,
 223                                          ALGO_WIFI_RSSI_STATE,
 224                                          "[BTCoex], wifi RSSI state "
 225                                          "stay at Low\n");
 226                        }
 227                } else if ((coex_sta->pre_wifi_rssi_state[index] ==
 228                                                BTC_RSSI_STATE_MEDIUM) ||
 229                           (coex_sta->pre_wifi_rssi_state[index] ==
 230                                                BTC_RSSI_STATE_STAY_MEDIUM)) {
 231                        if (wifi_rssi >= rssi_thresh1 +
 232                                         BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT) {
 233                                wifi_rssi_state = BTC_RSSI_STATE_HIGH;
 234                                BTC_PRINT(BTC_MSG_ALGORITHM,
 235                                          ALGO_WIFI_RSSI_STATE,
 236                                          "[BTCoex], wifi RSSI state "
 237                                          "switch to High\n");
 238                        } else if (wifi_rssi < rssi_thresh) {
 239                                wifi_rssi_state = BTC_RSSI_STATE_LOW;
 240                                BTC_PRINT(BTC_MSG_ALGORITHM,
 241                                          ALGO_WIFI_RSSI_STATE,
 242                                          "[BTCoex], wifi RSSI state "
 243                                          "switch to Low\n");
 244                        } else {
 245                                wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
 246                                BTC_PRINT(BTC_MSG_ALGORITHM,
 247                                          ALGO_WIFI_RSSI_STATE,
 248                                          "[BTCoex], wifi RSSI state "
 249                                          "stay at Medium\n");
 250                        }
 251                } else {
 252                        if (wifi_rssi < rssi_thresh1) {
 253                                wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
 254                                BTC_PRINT(BTC_MSG_ALGORITHM,
 255                                          ALGO_WIFI_RSSI_STATE,
 256                                          "[BTCoex], wifi RSSI state "
 257                                          "switch to Medium\n");
 258                        } else {
 259                                wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
 260                                BTC_PRINT(BTC_MSG_ALGORITHM,
 261                                          ALGO_WIFI_RSSI_STATE,
 262                                          "[BTCoex], wifi RSSI state "
 263                                          "stay at High\n");
 264                        }
 265                }
 266        }
 267
 268        coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state;
 269
 270        return wifi_rssi_state;
 271}
 272
 273static void btc8723b2ant_monitor_bt_ctr(struct btc_coexist *btcoexist)
 274{
 275        u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
 276        u32 reg_hp_tx = 0, reg_hp_rx = 0;
 277        u32 reg_lp_tx = 0, reg_lp_rx = 0;
 278
 279        reg_hp_txrx = 0x770;
 280        reg_lp_txrx = 0x774;
 281
 282        u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_txrx);
 283        reg_hp_tx = u32tmp & MASKLWORD;
 284        reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
 285
 286        u32tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_txrx);
 287        reg_lp_tx = u32tmp & MASKLWORD;
 288        reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
 289
 290        coex_sta->high_priority_tx = reg_hp_tx;
 291        coex_sta->high_priority_rx = reg_hp_rx;
 292        coex_sta->low_priority_tx = reg_lp_tx;
 293        coex_sta->low_priority_rx = reg_lp_rx;
 294
 295        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
 296                  "[BTCoex], High Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 297                  reg_hp_txrx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx);
 298        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR,
 299                  "[BTCoex], Low Priority Tx/Rx(reg 0x%x)=0x%x(%d)/0x%x(%d)\n",
 300                  reg_lp_txrx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx);
 301
 302        /* reset counter */
 303        btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
 304}
 305
 306static bool btc8723b2ant_is_wifi_status_changed(struct btc_coexist *btcoexist)
 307{
 308        static bool pre_wifi_busy;
 309        static bool pre_under_4way;
 310        static bool pre_bt_hs_on;
 311        bool wifi_busy = false, under_4way = false, bt_hs_on = false;
 312        bool wifi_connected = false;
 313
 314        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 315                           &wifi_connected);
 316        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
 317        btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 318        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS,
 319                           &under_4way);
 320
 321        if (wifi_connected) {
 322                if (wifi_busy != pre_wifi_busy) {
 323                        pre_wifi_busy = wifi_busy;
 324                        return true;
 325                }
 326
 327                if (under_4way != pre_under_4way) {
 328                        pre_under_4way = under_4way;
 329                        return true;
 330                }
 331
 332                if (bt_hs_on != pre_bt_hs_on) {
 333                        pre_bt_hs_on = bt_hs_on;
 334                        return true;
 335                }
 336        }
 337
 338        return false;
 339}
 340
 341static void btc8723b2ant_update_bt_link_info(struct btc_coexist *btcoexist)
 342{
 343        /*struct btc_stack_info *stack_info = &btcoexist->stack_info;*/
 344        struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 345        bool bt_hs_on = false;
 346
 347#if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1) /* profile from bt patch */
 348        btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 349
 350        bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
 351        bt_link_info->sco_exist = coex_sta->sco_exist;
 352        bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
 353        bt_link_info->pan_exist = coex_sta->pan_exist;
 354        bt_link_info->hid_exist = coex_sta->hid_exist;
 355
 356        /* work around for HS mode. */
 357        if (bt_hs_on) {
 358                bt_link_info->pan_exist = true;
 359                bt_link_info->bt_link_exist = true;
 360        }
 361#else   /* profile from bt stack */
 362        bt_link_info->bt_link_exist = stack_info->bt_link_exist;
 363        bt_link_info->sco_exist = stack_info->sco_exist;
 364        bt_link_info->a2dp_exist = stack_info->a2dp_exist;
 365        bt_link_info->pan_exist = stack_info->pan_exist;
 366        bt_link_info->hid_exist = stack_info->hid_exist;
 367
 368        /*for win-8 stack HID report error*/
 369        if (!stack_info->hid_exist)
 370                stack_info->hid_exist = coex_sta->hid_exist;
 371        /*sync  BTInfo with BT firmware and stack*/
 372        /* when stack HID report error, here we use the info from bt fw.*/
 373        if (!stack_info->bt_link_exist)
 374                stack_info->bt_link_exist = coex_sta->bt_link_exist;
 375#endif
 376        /* check if Sco only */
 377        if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 378            !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 379                bt_link_info->sco_only = true;
 380        else
 381                bt_link_info->sco_only = false;
 382
 383        /* check if A2dp only */
 384        if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
 385            !bt_link_info->pan_exist && !bt_link_info->hid_exist)
 386                bt_link_info->a2dp_only = true;
 387        else
 388                bt_link_info->a2dp_only = false;
 389
 390        /* check if Pan only */
 391        if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 392            bt_link_info->pan_exist && !bt_link_info->hid_exist)
 393                bt_link_info->pan_only = true;
 394        else
 395                bt_link_info->pan_only = false;
 396
 397        /* check if Hid only */
 398        if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
 399            !bt_link_info->pan_exist && bt_link_info->hid_exist)
 400                bt_link_info->hid_only = true;
 401        else
 402                bt_link_info->hid_only = false;
 403}
 404
 405static u8 btc8723b2ant_action_algorithm(struct btc_coexist *btcoexist)
 406{
 407        struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
 408        bool bt_hs_on = false;
 409        u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
 410        u8 num_of_diff_profile = 0;
 411
 412        btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
 413
 414        if (!bt_link_info->bt_link_exist) {
 415                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 416                          "[BTCoex], No BT link exists!!!\n");
 417                return algorithm;
 418        }
 419
 420        if (bt_link_info->sco_exist)
 421                num_of_diff_profile++;
 422        if (bt_link_info->hid_exist)
 423                num_of_diff_profile++;
 424        if (bt_link_info->pan_exist)
 425                num_of_diff_profile++;
 426        if (bt_link_info->a2dp_exist)
 427                num_of_diff_profile++;
 428
 429        if (num_of_diff_profile == 1) {
 430                if (bt_link_info->sco_exist) {
 431                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 432                                  "[BTCoex], SCO only\n");
 433                        algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 434                } else {
 435                        if (bt_link_info->hid_exist) {
 436                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 437                                          "[BTCoex], HID only\n");
 438                                algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 439                        } else if (bt_link_info->a2dp_exist) {
 440                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 441                                          "[BTCoex], A2DP only\n");
 442                                algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
 443                        } else if (bt_link_info->pan_exist) {
 444                                if (bt_hs_on) {
 445                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 446                                                  "[BTCoex], PAN(HS) only\n");
 447                                        algorithm =
 448                                                BT_8723B_2ANT_COEX_ALGO_PANHS;
 449                                } else {
 450                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 451                                                  "[BTCoex], PAN(EDR) only\n");
 452                                        algorithm =
 453                                                BT_8723B_2ANT_COEX_ALGO_PANEDR;
 454                                }
 455                        }
 456                }
 457        } else if (num_of_diff_profile == 2) {
 458                if (bt_link_info->sco_exist) {
 459                        if (bt_link_info->hid_exist) {
 460                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 461                                          "[BTCoex], SCO + HID\n");
 462                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 463                        } else if (bt_link_info->a2dp_exist) {
 464                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 465                                          "[BTCoex], SCO + A2DP ==> SCO\n");
 466                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 467                        } else if (bt_link_info->pan_exist) {
 468                                if (bt_hs_on) {
 469                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 470                                                  "[BTCoex], SCO + PAN(HS)\n");
 471                                        algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 472                                } else {
 473                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 474                                                  "[BTCoex], SCO + PAN(EDR)\n");
 475                                        algorithm =
 476                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 477                                }
 478                        }
 479                } else {
 480                        if (bt_link_info->hid_exist &&
 481                            bt_link_info->a2dp_exist) {
 482                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 483                                          "[BTCoex], HID + A2DP\n");
 484                                algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 485                        } else if (bt_link_info->hid_exist &&
 486                                   bt_link_info->pan_exist) {
 487                                if (bt_hs_on) {
 488                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 489                                                  "[BTCoex], HID + PAN(HS)\n");
 490                                        algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 491                                } else {
 492                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 493                                                  "[BTCoex], HID + PAN(EDR)\n");
 494                                        algorithm =
 495                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 496                                }
 497                        } else if (bt_link_info->pan_exist &&
 498                                   bt_link_info->a2dp_exist) {
 499                                if (bt_hs_on) {
 500                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 501                                                  "[BTCoex], A2DP + PAN(HS)\n");
 502                                        algorithm =
 503                                            BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
 504                                } else {
 505                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 506                                                  "[BTCoex],A2DP + PAN(EDR)\n");
 507                                        algorithm =
 508                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
 509                                }
 510                        }
 511                }
 512        } else if (num_of_diff_profile == 3) {
 513                if (bt_link_info->sco_exist) {
 514                        if (bt_link_info->hid_exist &&
 515                            bt_link_info->a2dp_exist) {
 516                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 517                                          "[BTCoex], SCO + HID + A2DP"
 518                                          " ==> HID\n");
 519                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 520                        } else if (bt_link_info->hid_exist &&
 521                                   bt_link_info->pan_exist) {
 522                                if (bt_hs_on) {
 523                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 524                                                  "[BTCoex], SCO + HID + "
 525                                                  "PAN(HS)\n");
 526                                        algorithm =
 527                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 528                                } else {
 529                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 530                                                  "[BTCoex], SCO + HID + "
 531                                                  "PAN(EDR)\n");
 532                                        algorithm =
 533                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 534                                }
 535                        } else if (bt_link_info->pan_exist &&
 536                                   bt_link_info->a2dp_exist) {
 537                                if (bt_hs_on) {
 538                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 539                                                  "[BTCoex], SCO + A2DP + "
 540                                                  "PAN(HS)\n");
 541                                        algorithm =
 542                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 543                                } else {
 544                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 545                                                  "[BTCoex], SCO + A2DP + "
 546                                                  "PAN(EDR) ==> HID\n");
 547                                        algorithm =
 548                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 549                                }
 550                        }
 551                } else {
 552                        if (bt_link_info->hid_exist &&
 553                            bt_link_info->pan_exist &&
 554                            bt_link_info->a2dp_exist) {
 555                                if (bt_hs_on) {
 556                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 557                                                  "[BTCoex], HID + A2DP + "
 558                                                  "PAN(HS)\n");
 559                                        algorithm =
 560                                            BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 561                                } else {
 562                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 563                                                  "[BTCoex], HID + A2DP + "
 564                                                  "PAN(EDR)\n");
 565                                        algorithm =
 566                                        BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 567                                }
 568                        }
 569                }
 570        } else if (num_of_diff_profile >= 3) {
 571                if (bt_link_info->sco_exist) {
 572                        if (bt_link_info->hid_exist &&
 573                            bt_link_info->pan_exist &&
 574                            bt_link_info->a2dp_exist) {
 575                                if (bt_hs_on) {
 576                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 577                                                  "[BTCoex], Error!!! SCO + HID"
 578                                                  " + A2DP + PAN(HS)\n");
 579                                } else {
 580                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
 581                                                  "[BTCoex], SCO + HID + A2DP +"
 582                                                  " PAN(EDR)==>PAN(EDR)+HID\n");
 583                                        algorithm =
 584                                            BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 585                                }
 586                        }
 587                }
 588        }
 589        return algorithm;
 590}
 591
 592static bool btc8723b_need_dec_pwr(struct btc_coexist *btcoexist)
 593{
 594        bool ret = false;
 595        bool bt_hs_on = false, wifi_connected = false;
 596        s32 bt_hs_rssi = 0;
 597        u8 bt_rssi_state;
 598
 599        if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on))
 600                return false;
 601        if (!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
 602                                &wifi_connected))
 603                return false;
 604        if (!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi))
 605                return false;
 606
 607        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
 608
 609        if (wifi_connected) {
 610                if (bt_hs_on) {
 611                        if (bt_hs_rssi > 37) {
 612                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
 613                                          "[BTCoex], Need to decrease bt "
 614                                          "power for HS mode!!\n");
 615                                ret = true;
 616                        }
 617                } else {
 618                        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
 619                            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
 620                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
 621                                          "[BTCoex], Need to decrease bt "
 622                                          "power for Wifi is connected!!\n");
 623                                ret = true;
 624                        }
 625                }
 626        }
 627
 628        return ret;
 629}
 630
 631static void btc8723b2ant_set_fw_dac_swing_level(struct btc_coexist *btcoexist,
 632                                                u8 dac_swing_lvl)
 633{
 634        u8 h2c_parameter[1] = {0};
 635
 636        /* There are several type of dacswing
 637         * 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6
 638         */
 639        h2c_parameter[0] = dac_swing_lvl;
 640
 641        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
 642                  "[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl);
 643        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
 644                  "[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0]);
 645
 646        btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter);
 647}
 648
 649static void btc8723b2ant_set_fw_dec_bt_pwr(struct btc_coexist *btcoexist,
 650                                           bool dec_bt_pwr)
 651{
 652        u8 h2c_parameter[1] = {0};
 653
 654        h2c_parameter[0] = 0;
 655
 656        if (dec_bt_pwr)
 657                h2c_parameter[0] |= BIT1;
 658
 659        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
 660                  "[BTCoex], decrease Bt Power : %s, FW write 0x62=0x%x\n",
 661                  (dec_bt_pwr ? "Yes!!" : "No!!"), h2c_parameter[0]);
 662
 663        btcoexist->btc_fill_h2c(btcoexist, 0x62, 1, h2c_parameter);
 664}
 665
 666static void btc8723b2ant_dec_bt_pwr(struct btc_coexist *btcoexist,
 667                                    bool force_exec, bool dec_bt_pwr)
 668{
 669        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
 670                  "[BTCoex], %s Dec BT power = %s\n",
 671                  (force_exec ? "force to" : ""), (dec_bt_pwr ? "ON" : "OFF"));
 672        coex_dm->cur_dec_bt_pwr = dec_bt_pwr;
 673
 674        if (!force_exec) {
 675                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
 676                          "[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
 677                          coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr);
 678
 679                if (coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr)
 680                        return;
 681        }
 682        btc8723b2ant_set_fw_dec_bt_pwr(btcoexist, coex_dm->cur_dec_bt_pwr);
 683
 684        coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr;
 685}
 686
 687static void btc8723b2ant_fw_dac_swing_lvl(struct btc_coexist *btcoexist,
 688                                          bool force_exec, u8 fw_dac_swing_lvl)
 689{
 690        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
 691                  "[BTCoex], %s set FW Dac Swing level = %d\n",
 692                  (force_exec ? "force to" : ""), fw_dac_swing_lvl);
 693        coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl;
 694
 695        if (!force_exec) {
 696                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
 697                          "[BTCoex], preFwDacSwingLvl=%d, "
 698                          "curFwDacSwingLvl=%d\n",
 699                          coex_dm->pre_fw_dac_swing_lvl,
 700                          coex_dm->cur_fw_dac_swing_lvl);
 701
 702                if (coex_dm->pre_fw_dac_swing_lvl ==
 703                   coex_dm->cur_fw_dac_swing_lvl)
 704                        return;
 705        }
 706
 707        btc8723b2ant_set_fw_dac_swing_level(btcoexist,
 708                                            coex_dm->cur_fw_dac_swing_lvl);
 709        coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl;
 710}
 711
 712static void btc8723b2ant_set_sw_rf_rx_lpf_corner(struct btc_coexist *btcoexist,
 713                                                 bool rx_rf_shrink_on)
 714{
 715        if (rx_rf_shrink_on) {
 716                /* Shrink RF Rx LPF corner */
 717                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 718                          "[BTCoex], Shrink RF Rx LPF corner!!\n");
 719                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
 720                                          0xfffff, 0xffffc);
 721        } else {
 722                /* Resume RF Rx LPF corner */
 723                /* After initialized, we can use coex_dm->btRf0x1eBackup */
 724                if (btcoexist->initilized) {
 725                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 726                                  "[BTCoex], Resume RF Rx LPF corner!!\n");
 727                        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e,
 728                                                  0xfffff,
 729                                                  coex_dm->bt_rf0x1e_backup);
 730                }
 731        }
 732}
 733
 734static void btc8723b2ant_rf_shrink(struct btc_coexist *btcoexist,
 735                                   bool force_exec, bool rx_rf_shrink_on)
 736{
 737        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
 738                  "[BTCoex], %s turn Rx RF Shrink = %s\n",
 739                  (force_exec ? "force to" : ""), (rx_rf_shrink_on ?
 740                  "ON" : "OFF"));
 741        coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on;
 742
 743        if (!force_exec) {
 744                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 745                          "[BTCoex], bPreRfRxLpfShrink=%d, "
 746                          "bCurRfRxLpfShrink=%d\n",
 747                          coex_dm->pre_rf_rx_lpf_shrink,
 748                          coex_dm->cur_rf_rx_lpf_shrink);
 749
 750                if (coex_dm->pre_rf_rx_lpf_shrink ==
 751                    coex_dm->cur_rf_rx_lpf_shrink)
 752                        return;
 753        }
 754        btc8723b2ant_set_sw_rf_rx_lpf_corner(btcoexist,
 755                                             coex_dm->cur_rf_rx_lpf_shrink);
 756
 757        coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink;
 758}
 759
 760static void btc8723b_set_penalty_txrate(struct btc_coexist *btcoexist,
 761                                        bool low_penalty_ra)
 762{
 763        u8 h2c_parameter[6] = {0};
 764
 765        h2c_parameter[0] = 0x6; /* opCode, 0x6= Retry_Penalty*/
 766
 767        if (low_penalty_ra) {
 768                h2c_parameter[1] |= BIT0;
 769                /*normal rate except MCS7/6/5, OFDM54/48/36*/
 770                h2c_parameter[2] = 0x00;
 771                h2c_parameter[3] = 0xf7;  /*MCS7 or OFDM54*/
 772                h2c_parameter[4] = 0xf8;  /*MCS6 or OFDM48*/
 773                h2c_parameter[5] = 0xf9;  /*MCS5 or OFDM36*/
 774        }
 775
 776        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
 777                  "[BTCoex], set WiFi Low-Penalty Retry: %s",
 778                  (low_penalty_ra ? "ON!!" : "OFF!!"));
 779
 780        btcoexist->btc_fill_h2c(btcoexist, 0x69, 6, h2c_parameter);
 781}
 782
 783static void btc8723b2ant_low_penalty_ra(struct btc_coexist *btcoexist,
 784                                        bool force_exec, bool low_penalty_ra)
 785{
 786        /*return; */
 787        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
 788                  "[BTCoex], %s turn LowPenaltyRA = %s\n",
 789                  (force_exec ? "force to" : ""), (low_penalty_ra ?
 790                  "ON" : "OFF"));
 791        coex_dm->cur_low_penalty_ra = low_penalty_ra;
 792
 793        if (!force_exec) {
 794                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 795                          "[BTCoex], bPreLowPenaltyRa=%d, "
 796                          "bCurLowPenaltyRa=%d\n",
 797                          coex_dm->pre_low_penalty_ra,
 798                          coex_dm->cur_low_penalty_ra);
 799
 800                if (coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra)
 801                        return;
 802        }
 803        btc8723b_set_penalty_txrate(btcoexist, coex_dm->cur_low_penalty_ra);
 804
 805        coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra;
 806}
 807
 808static void btc8723b2ant_set_dac_swing_reg(struct btc_coexist *btcoexist,
 809                                           u32 level)
 810{
 811        u8 val = (u8) level;
 812        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 813                  "[BTCoex], Write SwDacSwing = 0x%x\n", level);
 814        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x883, 0x3e, val);
 815}
 816
 817static void btc8723b2ant_set_sw_fulltime_dac_swing(struct btc_coexist *btcoex,
 818                                                   bool sw_dac_swing_on,
 819                                                   u32 sw_dac_swing_lvl)
 820{
 821        if (sw_dac_swing_on)
 822                btc8723b2ant_set_dac_swing_reg(btcoex, sw_dac_swing_lvl);
 823        else
 824                btc8723b2ant_set_dac_swing_reg(btcoex, 0x18);
 825}
 826
 827
 828static void btc8723b2ant_dac_swing(struct btc_coexist *btcoexist,
 829                                   bool force_exec, bool dac_swing_on,
 830                                   u32 dac_swing_lvl)
 831{
 832        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
 833                  "[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n",
 834                  (force_exec ? "force to" : ""),
 835                  (dac_swing_on ? "ON" : "OFF"), dac_swing_lvl);
 836        coex_dm->cur_dac_swing_on = dac_swing_on;
 837        coex_dm->cur_dac_swing_lvl = dac_swing_lvl;
 838
 839        if (!force_exec) {
 840                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 841                          "[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x,"
 842                          " bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
 843                          coex_dm->pre_dac_swing_on, coex_dm->pre_dac_swing_lvl,
 844                          coex_dm->cur_dac_swing_on,
 845                          coex_dm->cur_dac_swing_lvl);
 846
 847                if ((coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) &&
 848                    (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl))
 849                        return;
 850        }
 851        mdelay(30);
 852        btc8723b2ant_set_sw_fulltime_dac_swing(btcoexist, dac_swing_on,
 853                                               dac_swing_lvl);
 854
 855        coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on;
 856        coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl;
 857}
 858
 859static void btc8723b2ant_set_agc_table(struct btc_coexist *btcoexist,
 860                                       bool agc_table_en)
 861{
 862        u8 rssi_adjust_val = 0;
 863
 864        /*  BB AGC Gain Table */
 865        if (agc_table_en) {
 866                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 867                          "[BTCoex], BB Agc Table On!\n");
 868                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6e1A0001);
 869                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6d1B0001);
 870                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6c1C0001);
 871                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6b1D0001);
 872                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x6a1E0001);
 873                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x691F0001);
 874                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0x68200001);
 875        } else {
 876                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 877                          "[BTCoex], BB Agc Table Off!\n");
 878                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xaa1A0001);
 879                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa91B0001);
 880                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa81C0001);
 881                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa71D0001);
 882                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa61E0001);
 883                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa51F0001);
 884                btcoexist->btc_write_4byte(btcoexist, 0xc78, 0xa4200001);
 885        }
 886
 887
 888        /* RF Gain */
 889        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
 890        if (agc_table_en) {
 891                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 892                          "[BTCoex], Agc Table On!\n");
 893                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 894                                          0xfffff, 0x38fff);
 895                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 896                                          0xfffff, 0x38ffe);
 897        } else {
 898                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 899                          "[BTCoex], Agc Table Off!\n");
 900                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 901                                          0xfffff, 0x380c3);
 902                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b,
 903                                          0xfffff, 0x28ce6);
 904        }
 905        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
 906
 907        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
 908
 909        if (agc_table_en) {
 910                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 911                          "[BTCoex], Agc Table On!\n");
 912                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 913                                          0xfffff, 0x38fff);
 914                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 915                                          0xfffff, 0x38ffe);
 916        } else {
 917                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 918                          "[BTCoex], Agc Table Off!\n");
 919                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 920                                          0xfffff, 0x380c3);
 921                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x40,
 922                                          0xfffff, 0x28ce6);
 923        }
 924        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
 925
 926        /* set rssiAdjustVal for wifi module. */
 927        if (agc_table_en)
 928                rssi_adjust_val = 8;
 929        btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON,
 930                           &rssi_adjust_val);
 931}
 932
 933static void btc8723b2ant_agc_table(struct btc_coexist *btcoexist,
 934                                   bool force_exec, bool agc_table_en)
 935{
 936        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
 937                  "[BTCoex], %s %s Agc Table\n",
 938                  (force_exec ? "force to" : ""),
 939                  (agc_table_en ? "Enable" : "Disable"));
 940        coex_dm->cur_agc_table_en = agc_table_en;
 941
 942        if (!force_exec) {
 943                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 944                          "[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
 945                          coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en);
 946
 947                if (coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en)
 948                        return;
 949        }
 950        btc8723b2ant_set_agc_table(btcoexist, agc_table_en);
 951
 952        coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en;
 953}
 954
 955static void btc8723b2ant_set_coex_table(struct btc_coexist *btcoexist,
 956                                        u32 val0x6c0, u32 val0x6c4,
 957                                        u32 val0x6c8, u8 val0x6cc)
 958{
 959        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 960                  "[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0);
 961        btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0);
 962
 963        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 964                  "[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4);
 965        btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4);
 966
 967        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 968                  "[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8);
 969        btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8);
 970
 971        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC,
 972                  "[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc);
 973        btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc);
 974}
 975
 976static void btc8723b2ant_coex_table(struct btc_coexist *btcoexist,
 977                                    bool force_exec, u32 val0x6c0,
 978                                    u32 val0x6c4, u32 val0x6c8,
 979                                    u8 val0x6cc)
 980{
 981        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW,
 982                  "[BTCoex], %s write Coex Table 0x6c0=0x%x,"
 983                  " 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
 984                  (force_exec ? "force to" : ""), val0x6c0,
 985                  val0x6c4, val0x6c8, val0x6cc);
 986        coex_dm->cur_val0x6c0 = val0x6c0;
 987        coex_dm->cur_val0x6c4 = val0x6c4;
 988        coex_dm->cur_val0x6c8 = val0x6c8;
 989        coex_dm->cur_val0x6cc = val0x6cc;
 990
 991        if (!force_exec) {
 992                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 993                          "[BTCoex], preVal0x6c0=0x%x, "
 994                          "preVal0x6c4=0x%x, preVal0x6c8=0x%x, "
 995                          "preVal0x6cc=0x%x !!\n",
 996                          coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4,
 997                          coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc);
 998                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL,
 999                          "[BTCoex], curVal0x6c0=0x%x, "
1000                          "curVal0x6c4=0x%x, curVal0x6c8=0x%x, "

1001                          "curVal0x6cc=0x%x !!\n",
1002                          coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4,
1003                          coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc);
1004
1005                if ((coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) &&
1006                    (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) &&
1007                    (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) &&
1008                    (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc))
1009                        return;
1010        }
1011        btc8723b2ant_set_coex_table(btcoexist, val0x6c0, val0x6c4,
1012                                    val0x6c8, val0x6cc);
1013
1014        coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0;
1015        coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4;
1016        coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8;
1017        coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc;
1018}
1019
1020static void btc8723b_coex_tbl_type(struct btc_coexist *btcoexist,
1021                                   bool force_exec, u8 type)
1022{
1023        switch (type) {
1024        case 0:
1025                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
1026                                        0x55555555, 0xffff, 0x3);
1027                break;
1028        case 1:
1029                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55555555,
1030                                        0x5afa5afa, 0xffff, 0x3);
1031                break;
1032        case 2:
1033                btc8723b2ant_coex_table(btcoexist, force_exec, 0x5a5a5a5a,
1034                                        0x5a5a5a5a, 0xffff, 0x3);
1035                break;
1036        case 3:
1037                btc8723b2ant_coex_table(btcoexist, force_exec, 0xaaaaaaaa,
1038                                        0xaaaaaaaa, 0xffff, 0x3);
1039                break;
1040        case 4:
1041                btc8723b2ant_coex_table(btcoexist, force_exec, 0xffffffff,
1042                                        0xffffffff, 0xffff, 0x3);
1043                break;
1044        case 5:
1045                btc8723b2ant_coex_table(btcoexist, force_exec, 0x5fff5fff,
1046                                        0x5fff5fff, 0xffff, 0x3);
1047                break;
1048        case 6:
1049                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1050                                        0x5a5a5a5a, 0xffff, 0x3);
1051                break;
1052        case 7:
1053                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1054                                        0x5afa5afa, 0xffff, 0x3);
1055                break;
1056        case 8:
1057                btc8723b2ant_coex_table(btcoexist, force_exec, 0x5aea5aea,
1058                                        0x5aea5aea, 0xffff, 0x3);
1059                break;
1060        case 9:
1061                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1062                                        0x5aea5aea, 0xffff, 0x3);
1063                break;
1064        case 10:
1065                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1066                                        0x5aff5aff, 0xffff, 0x3);
1067                break;
1068        case 11:
1069                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1070                                        0x5a5f5a5f, 0xffff, 0x3);
1071                break;
1072        case 12:
1073                btc8723b2ant_coex_table(btcoexist, force_exec, 0x55ff55ff,
1074                                        0x5f5f5f5f, 0xffff, 0x3);
1075                break;
1076        default:
1077                break;
1078        }
1079}
1080
1081static void btc8723b2ant_set_fw_ignore_wlan_act(struct btc_coexist *btcoexist,
1082                                                bool enable)
1083{
1084        u8 h2c_parameter[1] = {0};
1085
1086        if (enable)
1087                h2c_parameter[0] |= BIT0;/* function enable*/
1088
1089        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
1090                  "[BTCoex], set FW for BT Ignore Wlan_Act, "
1091                  "FW write 0x63=0x%x\n", h2c_parameter[0]);
1092
1093        btcoexist->btc_fill_h2c(btcoexist, 0x63, 1, h2c_parameter);
1094}
1095
1096static void btc8723b2ant_ignore_wlan_act(struct btc_coexist *btcoexist,
1097                                         bool force_exec, bool enable)
1098{
1099        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
1100                  "[BTCoex], %s turn Ignore WlanAct %s\n",
1101                  (force_exec ? "force to" : ""), (enable ? "ON" : "OFF"));
1102        coex_dm->cur_ignore_wlan_act = enable;
1103
1104        if (!force_exec) {
1105                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1106                          "[BTCoex], bPreIgnoreWlanAct = %d, "
1107                          "bCurIgnoreWlanAct = %d!!\n",
1108                          coex_dm->pre_ignore_wlan_act,
1109                          coex_dm->cur_ignore_wlan_act);
1110
1111                if (coex_dm->pre_ignore_wlan_act ==
1112                    coex_dm->cur_ignore_wlan_act)
1113                        return;
1114        }
1115        btc8723b2ant_set_fw_ignore_wlan_act(btcoexist, enable);
1116
1117        coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act;
1118}
1119
1120static void btc8723b2ant_set_fw_ps_tdma(struct btc_coexist *btcoexist, u8 byte1,
1121                                        u8 byte2, u8 byte3, u8 byte4, u8 byte5)
1122{
1123        u8 h2c_parameter[5];
1124
1125        h2c_parameter[0] = byte1;
1126        h2c_parameter[1] = byte2;
1127        h2c_parameter[2] = byte3;
1128        h2c_parameter[3] = byte4;
1129        h2c_parameter[4] = byte5;
1130
1131        coex_dm->ps_tdma_para[0] = byte1;
1132        coex_dm->ps_tdma_para[1] = byte2;
1133        coex_dm->ps_tdma_para[2] = byte3;
1134        coex_dm->ps_tdma_para[3] = byte4;
1135        coex_dm->ps_tdma_para[4] = byte5;
1136
1137        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
1138                  "[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n",
1139                  h2c_parameter[0],
1140                  h2c_parameter[1] << 24 | h2c_parameter[2] << 16 |
1141                  h2c_parameter[3] << 8 | h2c_parameter[4]);
1142
1143        btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter);
1144}
1145
1146static void btc8723b2ant_sw_mechanism1(struct btc_coexist *btcoexist,
1147                                       bool shrink_rx_lpf, bool low_penalty_ra,
1148                                       bool limited_dig, bool bt_lna_constrain)
1149{
1150        btc8723b2ant_rf_shrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf);
1151        btc8723b2ant_low_penalty_ra(btcoexist, NORMAL_EXEC, low_penalty_ra);
1152}
1153
1154static void btc8723b2ant_sw_mechanism2(struct btc_coexist *btcoexist,
1155                                       bool agc_table_shift, bool adc_backoff,
1156                                       bool sw_dac_swing, u32 dac_swing_lvl)
1157{
1158        btc8723b2ant_agc_table(btcoexist, NORMAL_EXEC, agc_table_shift);
1159        btc8723b2ant_dac_swing(btcoexist, NORMAL_EXEC, sw_dac_swing,
1160                               dac_swing_lvl);
1161}
1162
1163static void btc8723b2ant_ps_tdma(struct btc_coexist *btcoexist, bool force_exec,
1164                             bool turn_on, u8 type)
1165{
1166        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
1167                  "[BTCoex], %s turn %s PS TDMA, type=%d\n",
1168                  (force_exec ? "force to" : ""),
1169                  (turn_on ? "ON" : "OFF"), type);
1170        coex_dm->cur_ps_tdma_on = turn_on;
1171        coex_dm->cur_ps_tdma = type;
1172
1173        if (!force_exec) {
1174                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1175                          "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1176                          coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on);
1177                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
1178                          "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1179                          coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma);
1180
1181                if ((coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) &&
1182                    (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma))
1183                        return;
1184        }
1185        if (turn_on) {
1186                switch (type) {
1187                case 1:
1188                default:
1189                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1190                                                    0x1a, 0xe1, 0x90);
1191                        break;
1192                case 2:
1193                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1194                                                    0x12, 0xe1, 0x90);
1195                        break;
1196                case 3:
1197                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1198                                                    0x3, 0xf1, 0x90);
1199                        break;
1200                case 4:
1201                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x10,
1202                                                    0x03, 0xf1, 0x90);
1203                        break;
1204                case 5:
1205                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1206                                                    0x1a, 0x60, 0x90);
1207                        break;
1208                case 6:
1209                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1210                                                    0x12, 0x60, 0x90);
1211                        break;
1212                case 7:
1213                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1c,
1214                                                    0x3, 0x70, 0x90);
1215                        break;
1216                case 8:
1217                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x10,
1218                                                    0x3, 0x70, 0x90);
1219                        break;
1220                case 9:
1221                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1222                                                    0x1a, 0xe1, 0x90);
1223                        break;
1224                case 10:
1225                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1226                                                    0x12, 0xe1, 0x90);
1227                        break;
1228                case 11:
1229                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1230                                                    0xa, 0xe1, 0x90);
1231                        break;
1232                case 12:
1233                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1234                                                    0x5, 0xe1, 0x90);
1235                        break;
1236                case 13:
1237                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1238                                                    0x1a, 0x60, 0x90);
1239                        break;
1240                case 14:
1241                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x12,
1242                                                    0x12, 0x60, 0x90);
1243                        break;
1244                case 15:
1245                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0xa,
1246                                                    0xa, 0x60, 0x90);
1247                        break;
1248                case 16:
1249                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1250                                                    0x5, 0x60, 0x90);
1251                        break;
1252                case 17:
1253                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xa3, 0x2f,
1254                                                    0x2f, 0x60, 0x90);
1255                        break;
1256                case 18:
1257                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x5,
1258                                                    0x5, 0xe1, 0x90);
1259                        break;
1260                case 19:
1261                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1262                                                    0x25, 0xe1, 0x90);
1263                        break;
1264                case 20:
1265                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x25,
1266                                                    0x25, 0x60, 0x90);
1267                        break;
1268                case 21:
1269                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x15,
1270                                                    0x03, 0x70, 0x90);
1271                        break;
1272                case 71:
1273                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0xe3, 0x1a,
1274                                                    0x1a, 0xe1, 0x90);
1275                        break;
1276                }
1277        } else {
1278                /* disable PS tdma */
1279                switch (type) {
1280                case 0:
1281                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1282                                                    0x40, 0x0);
1283                        break;
1284                case 1:
1285                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1286                                                    0x48, 0x0);
1287                        break;
1288                default:
1289                        btc8723b2ant_set_fw_ps_tdma(btcoexist, 0x0, 0x0, 0x0,
1290                                                    0x40, 0x0);
1291                        break;
1292                }
1293        }
1294
1295        /* update pre state */
1296        coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on;
1297        coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma;
1298}
1299
1300static void btc8723b2ant_coex_alloff(struct btc_coexist *btcoexist)
1301{
1302        /* fw all off */
1303        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1304        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1305        btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1306
1307        /* sw all off */
1308        btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1309        btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1310
1311        /* hw all off */
1312        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1313        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1314}
1315
1316static void btc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
1317{
1318        /* force to reset coex mechanism*/
1319
1320        btc8723b2ant_ps_tdma(btcoexist, FORCE_EXEC, false, 1);
1321        btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1322        btc8723b2ant_dec_bt_pwr(btcoexist, FORCE_EXEC, false);
1323
1324        btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1325        btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1326}
1327
1328static void btc8723b2ant_action_bt_inquiry(struct btc_coexist *btcoexist)
1329{
1330        bool wifi_connected = false;
1331        bool low_pwr_disable = true;
1332
1333        btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1334                           &low_pwr_disable);
1335        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
1336                           &wifi_connected);
1337
1338        if (wifi_connected) {
1339                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
1340                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1341        } else {
1342                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1343                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1344        }
1345        btc8723b2ant_fw_dac_swing_lvl(btcoexist, FORCE_EXEC, 6);
1346        btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1347
1348        btc8723b2ant_sw_mechanism1(btcoexist, false, false, false, false);
1349        btc8723b2ant_sw_mechanism2(btcoexist, false, false, false, 0x18);
1350
1351        coex_dm->need_recover_0x948 = true;
1352        coex_dm->backup_0x948 = btcoexist->btc_read_2byte(btcoexist, 0x948);
1353
1354        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x280);
1355}
1356
1357static bool btc8723b2ant_is_common_action(struct btc_coexist *btcoexist)
1358{
1359        bool common = false, wifi_connected = false;
1360        bool wifi_busy = false;
1361        bool bt_hs_on = false, low_pwr_disable = false;
1362
1363        btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
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        if (!wifi_connected) {
1369                low_pwr_disable = false;
1370                btcoexist->btc_set(btcoexist, BTC_SET_ACT_DISABLE_LOW_POWER,
1371                                   &low_pwr_disable);
1372
1373                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1374                          "[BTCoex], Wifi non-connected idle!!\n");
1375
1376                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
1377                                          0x0);
1378                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1379                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1380                btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
1381                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
1382
1383                btc8723b2ant_sw_mechanism1(btcoexist, false, false, false,
1384                                           false);
1385                btc8723b2ant_sw_mechanism2(btcoexist, false, false, false,
1386                                           0x18);
1387
1388                common = true;
1389        } else {
1390                if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE ==
1391                    coex_dm->bt_status) {
1392                        low_pwr_disable = false;
1393                        btcoexist->btc_set(btcoexist,
1394                                           BTC_SET_ACT_DISABLE_LOW_POWER,
1395                                           &low_pwr_disable);
1396
1397                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1398                                  "[BTCoex], Wifi connected + "
1399                                  "BT non connected-idle!!\n");
1400
1401                        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1402                                                  0xfffff, 0x0);
1403                        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1404                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1405                        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1406                                                      0xb);
1407                        btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1408                                                false);
1409
1410                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
1411                                                   false, false);
1412                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1413                                                   false, 0x18);
1414
1415                        common = true;
1416                } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE ==
1417                           coex_dm->bt_status) {
1418                        low_pwr_disable = true;
1419                        btcoexist->btc_set(btcoexist,
1420                                           BTC_SET_ACT_DISABLE_LOW_POWER,
1421                                           &low_pwr_disable);
1422
1423                        if (bt_hs_on)
1424                                return false;
1425                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1426                                  "[BTCoex], Wifi connected + "
1427                                  "BT connected-idle!!\n");
1428
1429                        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
1430                                                  0xfffff, 0x0);
1431                        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 0);
1432                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
1433                        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
1434                                                      0xb);
1435                        btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC,
1436                                                false);
1437
1438                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
1439                                                   false, false);
1440                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
1441                                                   false, 0x18);
1442
1443                        common = true;
1444                } else {
1445                        low_pwr_disable = true;
1446                        btcoexist->btc_set(btcoexist,
1447                                           BTC_SET_ACT_DISABLE_LOW_POWER,
1448                                           &low_pwr_disable);
1449
1450                        if (wifi_busy) {
1451                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1452                                          "[BTCoex], Wifi Connected-Busy + "
1453                                          "BT Busy!!\n");
1454                                common = false;
1455                        } else {
1456                                if (bt_hs_on)
1457                                        return false;
1458
1459                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
1460                                          "[BTCoex], Wifi Connected-Idle + "
1461                                          "BT Busy!!\n");
1462
1463                                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A,
1464                                                          0x1, 0xfffff, 0x0);
1465                                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC,
1466                                                       7);
1467                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1468                                                     true, 21);
1469                                btc8723b2ant_fw_dac_swing_lvl(btcoexist,
1470                                                              NORMAL_EXEC,
1471                                                              0xb);
1472                                if (btc8723b_need_dec_pwr(btcoexist))
1473                                        btc8723b2ant_dec_bt_pwr(btcoexist,
1474                                                                NORMAL_EXEC,
1475                                                                true);
1476                                else
1477                                        btc8723b2ant_dec_bt_pwr(btcoexist,
1478                                                                NORMAL_EXEC,
1479                                                                false);
1480                                btc8723b2ant_sw_mechanism1(btcoexist, false,
1481                                                           false, false,
1482                                                           false);
1483                                btc8723b2ant_sw_mechanism2(btcoexist, false,
1484                                                           false, false,
1485                                                           0x18);
1486                                common = true;
1487                        }
1488                }
1489        }
1490
1491        return common;
1492}
1493
1494static void set_tdma_int1(struct btc_coexist *btcoexist, bool tx_pause,
1495                          s32 result)
1496{
1497        /* Set PS TDMA for max interval == 1 */
1498        if (tx_pause) {
1499                BTC_PRINT(BTC_MSG_ALGORITHM,
1500                          ALGO_TRACE_FW_DETAIL,
1501                          "[BTCoex], TxPause = 1\n");
1502
1503                if (coex_dm->cur_ps_tdma == 71) {
1504                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1505                                             true, 5);
1506                        coex_dm->tdma_adj_type = 5;
1507                } else if (coex_dm->cur_ps_tdma == 1) {
1508                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1509                                             true, 5);
1510                        coex_dm->tdma_adj_type = 5;
1511                } else if (coex_dm->cur_ps_tdma == 2) {
1512                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1513                                             true, 6);
1514                        coex_dm->tdma_adj_type = 6;
1515                } else if (coex_dm->cur_ps_tdma == 3) {
1516                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1517                                             true, 7);
1518                        coex_dm->tdma_adj_type = 7;
1519                } else if (coex_dm->cur_ps_tdma == 4) {
1520                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1521                                             true, 8);
1522                        coex_dm->tdma_adj_type = 8;
1523                } else if (coex_dm->cur_ps_tdma == 9) {
1524                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1525                                             true, 13);
1526                        coex_dm->tdma_adj_type = 13;
1527                } else if (coex_dm->cur_ps_tdma == 10) {
1528                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1529                                             true, 14);
1530                        coex_dm->tdma_adj_type = 14;
1531                } else if (coex_dm->cur_ps_tdma == 11) {
1532                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1533                                             true, 15);
1534                        coex_dm->tdma_adj_type = 15;
1535                } else if (coex_dm->cur_ps_tdma == 12) {
1536                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1537                                             true, 16);
1538                        coex_dm->tdma_adj_type = 16;
1539                }
1540
1541                if (result == -1) {
1542                        if (coex_dm->cur_ps_tdma == 5) {
1543                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1544                                                     true, 6);
1545                                coex_dm->tdma_adj_type = 6;
1546                        } else if (coex_dm->cur_ps_tdma == 6) {
1547                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1548                                                     true, 7);
1549                                coex_dm->tdma_adj_type = 7;
1550                        } else if (coex_dm->cur_ps_tdma == 7) {
1551                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1552                                                     true, 8);
1553                                coex_dm->tdma_adj_type = 8;
1554                        } else if (coex_dm->cur_ps_tdma == 13) {
1555                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1556                                                     true, 14);
1557                                coex_dm->tdma_adj_type = 14;
1558                        } else if (coex_dm->cur_ps_tdma == 14) {
1559                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1560                                                     true, 15);
1561                                coex_dm->tdma_adj_type = 15;
1562                        } else if (coex_dm->cur_ps_tdma == 15) {
1563                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1564                                                     true, 16);
1565                                coex_dm->tdma_adj_type = 16;
1566                        }
1567                }  else if (result == 1) {
1568                        if (coex_dm->cur_ps_tdma == 8) {
1569                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1570                                                     true, 7);
1571                                coex_dm->tdma_adj_type = 7;
1572                        } else if (coex_dm->cur_ps_tdma == 7) {
1573                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1574                                                     true, 6);
1575                                coex_dm->tdma_adj_type = 6;
1576                        } else if (coex_dm->cur_ps_tdma == 6) {
1577                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1578                                                     true, 5);
1579                                coex_dm->tdma_adj_type = 5;
1580                        } else if (coex_dm->cur_ps_tdma == 16) {
1581                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1582                                                     true, 15);
1583                                coex_dm->tdma_adj_type = 15;
1584                        } else if (coex_dm->cur_ps_tdma == 15) {
1585                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1586                                                     true, 14);
1587                                coex_dm->tdma_adj_type = 14;
1588                        } else if (coex_dm->cur_ps_tdma == 14) {
1589                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1590                                                     true, 13);
1591                                coex_dm->tdma_adj_type = 13;
1592                        }
1593                }
1594        } else {
1595                BTC_PRINT(BTC_MSG_ALGORITHM,
1596                          ALGO_TRACE_FW_DETAIL,
1597                          "[BTCoex], TxPause = 0\n");
1598                if (coex_dm->cur_ps_tdma == 5) {
1599                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 71);
1600                        coex_dm->tdma_adj_type = 71;
1601                } else if (coex_dm->cur_ps_tdma == 6) {
1602                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1603                        coex_dm->tdma_adj_type = 2;
1604                } else if (coex_dm->cur_ps_tdma == 7) {
1605                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1606                        coex_dm->tdma_adj_type = 3;
1607                } else if (coex_dm->cur_ps_tdma == 8) {
1608                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1609                        coex_dm->tdma_adj_type = 4;
1610                } else if (coex_dm->cur_ps_tdma == 13) {
1611                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
1612                        coex_dm->tdma_adj_type = 9;
1613                } else if (coex_dm->cur_ps_tdma == 14) {
1614                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1615                        coex_dm->tdma_adj_type = 10;
1616                } else if (coex_dm->cur_ps_tdma == 15) {
1617                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1618                        coex_dm->tdma_adj_type = 11;
1619                } else if (coex_dm->cur_ps_tdma == 16) {
1620                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1621                        coex_dm->tdma_adj_type = 12;
1622                }
1623
1624                if (result == -1) {
1625                        if (coex_dm->cur_ps_tdma == 71) {
1626                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1627                                                     true, 1);
1628                                coex_dm->tdma_adj_type = 1;
1629                        } else if (coex_dm->cur_ps_tdma == 1) {
1630                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1631                                                     true, 2);
1632                                coex_dm->tdma_adj_type = 2;
1633                        } else if (coex_dm->cur_ps_tdma == 2) {
1634                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1635                                                     true, 3);
1636                                coex_dm->tdma_adj_type = 3;
1637                        } else if (coex_dm->cur_ps_tdma == 3) {
1638                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1639                                                     true, 4);
1640                                coex_dm->tdma_adj_type = 4;
1641                        } else if (coex_dm->cur_ps_tdma == 9) {
1642                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1643                                                     true, 10);
1644                                coex_dm->tdma_adj_type = 10;
1645                        } else if (coex_dm->cur_ps_tdma == 10) {
1646                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1647                                                     true, 11);
1648                                coex_dm->tdma_adj_type = 11;
1649                        } else if (coex_dm->cur_ps_tdma == 11) {
1650                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1651                                                     true, 12);
1652                                coex_dm->tdma_adj_type = 12;
1653                        }
1654                }  else if (result == 1) {
1655                        int tmp = coex_dm->cur_ps_tdma;
1656                        switch (tmp) {
1657                        case 4:
1658                        case 3:
1659                        case 2:
1660                        case 12:
1661                        case 11:
1662                        case 10:
1663                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1664                                                     true, tmp - 1);
1665                                coex_dm->tdma_adj_type = tmp - 1;
1666                                break;
1667                        case 1:
1668                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1669                                                     true, 71);
1670                                coex_dm->tdma_adj_type = 71;
1671                                break;
1672                        }
1673                }
1674        }
1675}
1676
1677static void set_tdma_int2(struct btc_coexist *btcoexist, bool tx_pause,
1678                          s32 result)
1679{
1680        /* Set PS TDMA for max interval == 2 */
1681        if (tx_pause) {
1682                BTC_PRINT(BTC_MSG_ALGORITHM,
1683                          ALGO_TRACE_FW_DETAIL,
1684                          "[BTCoex], TxPause = 1\n");
1685                if (coex_dm->cur_ps_tdma == 1) {
1686                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1687                        coex_dm->tdma_adj_type = 6;
1688                } else if (coex_dm->cur_ps_tdma == 2) {
1689                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 6);
1690                        coex_dm->tdma_adj_type = 6;
1691                } else if (coex_dm->cur_ps_tdma == 3) {
1692                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1693                        coex_dm->tdma_adj_type = 7;
1694                } else if (coex_dm->cur_ps_tdma == 4) {
1695                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1696                        coex_dm->tdma_adj_type = 8;
1697                } else if (coex_dm->cur_ps_tdma == 9) {
1698                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1699                        coex_dm->tdma_adj_type = 14;
1700                } else if (coex_dm->cur_ps_tdma == 10) {
1701                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 14);
1702                        coex_dm->tdma_adj_type = 14;
1703                } else if (coex_dm->cur_ps_tdma == 11) {
1704                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1705                        coex_dm->tdma_adj_type = 15;
1706                } else if (coex_dm->cur_ps_tdma == 12) {
1707                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1708                        coex_dm->tdma_adj_type = 16;
1709                }
1710                if (result == -1) {
1711                        if (coex_dm->cur_ps_tdma == 5) {
1712                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1713                                                     true, 6);
1714                                coex_dm->tdma_adj_type = 6;
1715                        } else if (coex_dm->cur_ps_tdma == 6) {
1716                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1717                                                     true, 7);
1718                                coex_dm->tdma_adj_type = 7;
1719                        } else if (coex_dm->cur_ps_tdma == 7) {
1720                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1721                                                     true, 8);
1722                                coex_dm->tdma_adj_type = 8;
1723                        } else if (coex_dm->cur_ps_tdma == 13) {
1724                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1725                                                     true, 14);
1726                                coex_dm->tdma_adj_type = 14;
1727                        } else if (coex_dm->cur_ps_tdma == 14) {
1728                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1729                                                     true, 15);
1730                                coex_dm->tdma_adj_type = 15;
1731                        } else if (coex_dm->cur_ps_tdma == 15) {
1732                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1733                                                     true, 16);
1734                                coex_dm->tdma_adj_type = 16;
1735                        }
1736                }  else if (result == 1) {
1737                        if (coex_dm->cur_ps_tdma == 8) {
1738                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1739                                                     true, 7);
1740                                coex_dm->tdma_adj_type = 7;
1741                        } else if (coex_dm->cur_ps_tdma == 7) {
1742                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1743                                                     true, 6);
1744                                coex_dm->tdma_adj_type = 6;
1745                        } else if (coex_dm->cur_ps_tdma == 6) {
1746                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1747                                                     true, 6);
1748                                coex_dm->tdma_adj_type = 6;
1749                        } else if (coex_dm->cur_ps_tdma == 16) {
1750                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1751                                                     true, 15);
1752                                coex_dm->tdma_adj_type = 15;
1753                        } else if (coex_dm->cur_ps_tdma == 15) {
1754                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1755                                                     true, 14);
1756                                coex_dm->tdma_adj_type = 14;
1757                        } else if (coex_dm->cur_ps_tdma == 14) {
1758                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1759                                                     true, 14);
1760                                coex_dm->tdma_adj_type = 14;
1761                        }
1762                }
1763        } else {
1764                BTC_PRINT(BTC_MSG_ALGORITHM,
1765                          ALGO_TRACE_FW_DETAIL,
1766                          "[BTCoex], TxPause = 0\n");
1767                if (coex_dm->cur_ps_tdma == 5) {
1768                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1769                        coex_dm->tdma_adj_type = 2;
1770                } else if (coex_dm->cur_ps_tdma == 6) {
1771                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 2);
1772                        coex_dm->tdma_adj_type = 2;
1773                } else if (coex_dm->cur_ps_tdma == 7) {
1774                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1775                        coex_dm->tdma_adj_type = 3;
1776                } else if (coex_dm->cur_ps_tdma == 8) {
1777                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1778                        coex_dm->tdma_adj_type = 4;
1779                } else if (coex_dm->cur_ps_tdma == 13) {
1780                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1781                        coex_dm->tdma_adj_type = 10;
1782                } else if (coex_dm->cur_ps_tdma == 14) {
1783                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 10);
1784                        coex_dm->tdma_adj_type = 10;
1785                } else if (coex_dm->cur_ps_tdma == 15) {
1786                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1787                        coex_dm->tdma_adj_type = 11;
1788                } else if (coex_dm->cur_ps_tdma == 16) {
1789                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1790                        coex_dm->tdma_adj_type = 12;
1791                }
1792                if (result == -1) {
1793                        if (coex_dm->cur_ps_tdma == 1) {
1794                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1795                                                     true, 2);
1796                                coex_dm->tdma_adj_type = 2;
1797                        } else if (coex_dm->cur_ps_tdma == 2) {
1798                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1799                                                     true, 3);
1800                                coex_dm->tdma_adj_type = 3;
1801                        } else if (coex_dm->cur_ps_tdma == 3) {
1802                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1803                                                     true, 4);
1804                                coex_dm->tdma_adj_type = 4;
1805                        } else if (coex_dm->cur_ps_tdma == 9) {
1806                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1807                                                     true, 10);
1808                                coex_dm->tdma_adj_type = 10;
1809                        } else if (coex_dm->cur_ps_tdma == 10) {
1810                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1811                                                     true, 11);
1812                                coex_dm->tdma_adj_type = 11;
1813                        } else if (coex_dm->cur_ps_tdma == 11) {
1814                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1815                                                     true, 12);
1816                                coex_dm->tdma_adj_type = 12;
1817                        }
1818                } else if (result == 1) {
1819                        if (coex_dm->cur_ps_tdma == 4) {
1820                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1821                                                     true, 3);
1822                                coex_dm->tdma_adj_type = 3;
1823                        } else if (coex_dm->cur_ps_tdma == 3) {
1824                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1825                                                     true, 2);
1826                                coex_dm->tdma_adj_type = 2;
1827                        } else if (coex_dm->cur_ps_tdma == 2) {
1828                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1829                                                     true, 2);
1830                                coex_dm->tdma_adj_type = 2;
1831                        } else if (coex_dm->cur_ps_tdma == 12) {
1832                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1833                                                     true, 11);
1834                                coex_dm->tdma_adj_type = 11;
1835                        } else if (coex_dm->cur_ps_tdma == 11) {
1836                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1837                                                     true, 10);
1838                                coex_dm->tdma_adj_type = 10;
1839                        } else if (coex_dm->cur_ps_tdma == 10) {
1840                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1841                                                     true, 10);
1842                                coex_dm->tdma_adj_type = 10;
1843                        }
1844                }
1845        }
1846}
1847
1848static void set_tdma_int3(struct btc_coexist *btcoexist, bool tx_pause,
1849                          s32 result)
1850{
1851        /* Set PS TDMA for max interval == 3 */
1852        if (tx_pause) {
1853                BTC_PRINT(BTC_MSG_ALGORITHM,
1854                          ALGO_TRACE_FW_DETAIL,
1855                          "[BTCoex], TxPause = 1\n");
1856                if (coex_dm->cur_ps_tdma == 1) {
1857                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1858                        coex_dm->tdma_adj_type = 7;
1859                } else if (coex_dm->cur_ps_tdma == 2) {
1860                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1861                        coex_dm->tdma_adj_type = 7;
1862                } else if (coex_dm->cur_ps_tdma == 3) {
1863                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 7);
1864                        coex_dm->tdma_adj_type = 7;
1865                } else if (coex_dm->cur_ps_tdma == 4) {
1866                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 8);
1867                        coex_dm->tdma_adj_type = 8;
1868                } else if (coex_dm->cur_ps_tdma == 9) {
1869                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1870                        coex_dm->tdma_adj_type = 15;
1871                } else if (coex_dm->cur_ps_tdma == 10) {
1872                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1873                        coex_dm->tdma_adj_type = 15;
1874                } else if (coex_dm->cur_ps_tdma == 11) {
1875                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 15);
1876                        coex_dm->tdma_adj_type = 15;
1877                } else if (coex_dm->cur_ps_tdma == 12) {
1878                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 16);
1879                        coex_dm->tdma_adj_type = 16;
1880                }
1881                if (result == -1) {
1882                        if (coex_dm->cur_ps_tdma == 5) {
1883                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1884                                                     true, 7);
1885                                coex_dm->tdma_adj_type = 7;
1886                        } else if (coex_dm->cur_ps_tdma == 6) {
1887                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1888                                                     true, 7);
1889                                coex_dm->tdma_adj_type = 7;
1890                        } else if (coex_dm->cur_ps_tdma == 7) {
1891                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1892                                                     true, 8);
1893                                coex_dm->tdma_adj_type = 8;
1894                        } else if (coex_dm->cur_ps_tdma == 13) {
1895                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1896                                                     true, 15);
1897                                coex_dm->tdma_adj_type = 15;
1898                        } else if (coex_dm->cur_ps_tdma == 14) {
1899                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1900                                                     true, 15);
1901                                coex_dm->tdma_adj_type = 15;
1902                        } else if (coex_dm->cur_ps_tdma == 15) {
1903                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1904                                                     true, 16);
1905                                coex_dm->tdma_adj_type = 16;
1906                        }
1907                }  else if (result == 1) {
1908                        if (coex_dm->cur_ps_tdma == 8) {
1909                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1910                                                     true, 7);
1911                                coex_dm->tdma_adj_type = 7;
1912                        } else if (coex_dm->cur_ps_tdma == 7) {
1913                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1914                                                     true, 7);
1915                                coex_dm->tdma_adj_type = 7;
1916                        } else if (coex_dm->cur_ps_tdma == 6) {
1917                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1918                                                     true, 7);
1919                                coex_dm->tdma_adj_type = 7;
1920                        } else if (coex_dm->cur_ps_tdma == 16) {
1921                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1922                                                     true, 15);
1923                                coex_dm->tdma_adj_type = 15;
1924                        } else if (coex_dm->cur_ps_tdma == 15) {
1925                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1926                                                     true, 15);
1927                                coex_dm->tdma_adj_type = 15;
1928                        } else if (coex_dm->cur_ps_tdma == 14) {
1929                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1930                                                     true, 15);
1931                                coex_dm->tdma_adj_type = 15;
1932                        }
1933                }
1934        } else {
1935                BTC_PRINT(BTC_MSG_ALGORITHM,
1936                          ALGO_TRACE_FW_DETAIL,
1937                          "[BTCoex], TxPause = 0\n");
1938                switch (coex_dm->cur_ps_tdma) {
1939                case 5:
1940                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1941                        coex_dm->tdma_adj_type = 3;
1942                        break;
1943                case 6:
1944                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1945                        coex_dm->tdma_adj_type = 3;
1946                        break;
1947                case 7:
1948                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 3);
1949                        coex_dm->tdma_adj_type = 3;
1950                        break;
1951                case 8:
1952                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 4);
1953                        coex_dm->tdma_adj_type = 4;
1954                        break;
1955                case 13:
1956                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1957                        coex_dm->tdma_adj_type = 11;
1958                        break;
1959                case 14:
1960                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1961                        coex_dm->tdma_adj_type = 11;
1962                        break;
1963                case 15:
1964                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 11);
1965                        coex_dm->tdma_adj_type = 11;
1966                        break;
1967                case 16:
1968                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 12);
1969                        coex_dm->tdma_adj_type = 12;
1970                        break;
1971                }
1972                if (result == -1) {
1973                        switch (coex_dm->cur_ps_tdma) {
1974                        case 1:
1975                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1976                                                     true, 3);
1977                                coex_dm->tdma_adj_type = 3;
1978                                break;
1979                        case 2:
1980                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1981                                                     true, 3);
1982                                coex_dm->tdma_adj_type = 3;
1983                                break;
1984                        case 3:
1985                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1986                                                     true, 4);
1987                                coex_dm->tdma_adj_type = 4;
1988                                break;
1989                        case 9:
1990                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1991                                                     true, 11);
1992                                coex_dm->tdma_adj_type = 11;
1993                                break;
1994                        case 10:
1995                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
1996                                                     true, 11);
1997                                coex_dm->tdma_adj_type = 11;
1998                                break;
1999                        case 11:
2000                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,

2001                                                     true, 12);
2002                                coex_dm->tdma_adj_type = 12;
2003                                break;
2004                        }
2005                } else if (result == 1) {
2006                        switch (coex_dm->cur_ps_tdma) {
2007                        case 4:
2008                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2009                                                     true, 3);
2010                                coex_dm->tdma_adj_type = 3;
2011                                break;
2012                        case 3:
2013                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2014                                                     true, 3);
2015                                coex_dm->tdma_adj_type = 3;
2016                                break;
2017                        case 2:
2018                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2019                                                     true, 3);
2020                                coex_dm->tdma_adj_type = 3;
2021                                break;
2022                        case 12:
2023                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2024                                                     true, 11);
2025                                coex_dm->tdma_adj_type = 11;
2026                                break;
2027                        case 11:
2028                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2029                                                     true, 11);
2030                                coex_dm->tdma_adj_type = 11;
2031                                break;
2032                        case 10:
2033                                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC,
2034                                                     true, 11);
2035                                coex_dm->tdma_adj_type = 11;
2036                        }
2037                }
2038        }
2039}
2040
2041static void btc8723b2ant_tdma_duration_adjust(struct btc_coexist *btcoexist,
2042                                          bool sco_hid, bool tx_pause,
2043                                          u8 max_interval)
2044{
2045        static s32 up, dn, m, n, wait_count;
2046        /*0: no change, +1: increase WiFi duration, -1: decrease WiFi duration*/
2047        s32 result;
2048        u8 retry_count = 0;
2049
2050        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW,
2051                  "[BTCoex], TdmaDurationAdjust()\n");
2052
2053        if (!coex_dm->auto_tdma_adjust) {
2054                coex_dm->auto_tdma_adjust = true;
2055                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2056                          "[BTCoex], first run TdmaDurationAdjust()!!\n");
2057                if (sco_hid) {
2058                        if (tx_pause) {
2059                                if (max_interval == 1) {
2060                                        btc8723b2ant_ps_tdma(btcoexist,
2061                                                             NORMAL_EXEC,
2062                                                             true, 13);
2063                                        coex_dm->tdma_adj_type = 13;
2064                                } else if (max_interval == 2) {
2065                                        btc8723b2ant_ps_tdma(btcoexist,
2066                                                             NORMAL_EXEC,
2067                                                             true, 14);
2068                                        coex_dm->tdma_adj_type = 14;
2069                                } else if (max_interval == 3) {
2070                                        btc8723b2ant_ps_tdma(btcoexist,
2071                                                             NORMAL_EXEC,
2072                                                             true, 15);
2073                                        coex_dm->tdma_adj_type = 15;
2074                                } else {
2075                                        btc8723b2ant_ps_tdma(btcoexist,
2076                                                             NORMAL_EXEC,
2077                                                             true, 15);
2078                                        coex_dm->tdma_adj_type = 15;
2079                                }
2080                        } else {
2081                                if (max_interval == 1) {
2082                                        btc8723b2ant_ps_tdma(btcoexist,
2083                                                             NORMAL_EXEC,
2084                                                             true, 9);
2085                                        coex_dm->tdma_adj_type = 9;
2086                                } else if (max_interval == 2) {
2087                                        btc8723b2ant_ps_tdma(btcoexist,
2088                                                             NORMAL_EXEC,
2089                                                             true, 10);
2090                                        coex_dm->tdma_adj_type = 10;
2091                                } else if (max_interval == 3) {
2092                                        btc8723b2ant_ps_tdma(btcoexist,
2093                                                             NORMAL_EXEC,
2094                                                             true, 11);
2095                                        coex_dm->tdma_adj_type = 11;
2096                                } else {
2097                                        btc8723b2ant_ps_tdma(btcoexist,
2098                                                             NORMAL_EXEC,
2099                                                             true, 11);
2100                                        coex_dm->tdma_adj_type = 11;
2101                                }
2102                        }
2103                } else {
2104                        if (tx_pause) {
2105                                if (max_interval == 1) {
2106                                        btc8723b2ant_ps_tdma(btcoexist,
2107                                                             NORMAL_EXEC,
2108                                                             true, 5);
2109                                        coex_dm->tdma_adj_type = 5;
2110                                } else if (max_interval == 2) {
2111                                        btc8723b2ant_ps_tdma(btcoexist,
2112                                                             NORMAL_EXEC,
2113                                                             true, 6);
2114                                        coex_dm->tdma_adj_type = 6;
2115                                } else if (max_interval == 3) {
2116                                        btc8723b2ant_ps_tdma(btcoexist,
2117                                                             NORMAL_EXEC,
2118                                                             true, 7);
2119                                        coex_dm->tdma_adj_type = 7;
2120                                } else {
2121                                        btc8723b2ant_ps_tdma(btcoexist,
2122                                                             NORMAL_EXEC,
2123                                                             true, 7);
2124                                        coex_dm->tdma_adj_type = 7;
2125                                }
2126                        } else {
2127                                if (max_interval == 1) {
2128                                        btc8723b2ant_ps_tdma(btcoexist,
2129                                                             NORMAL_EXEC,
2130                                                             true, 1);
2131                                        coex_dm->tdma_adj_type = 1;
2132                                } else if (max_interval == 2) {
2133                                        btc8723b2ant_ps_tdma(btcoexist,
2134                                                             NORMAL_EXEC,
2135                                                             true, 2);
2136                                        coex_dm->tdma_adj_type = 2;
2137                                } else if (max_interval == 3) {
2138                                        btc8723b2ant_ps_tdma(btcoexist,
2139                                                             NORMAL_EXEC,
2140                                                             true, 3);
2141                                        coex_dm->tdma_adj_type = 3;
2142                                } else {
2143                                        btc8723b2ant_ps_tdma(btcoexist,
2144                                                             NORMAL_EXEC,
2145                                                             true, 3);
2146                                        coex_dm->tdma_adj_type = 3;
2147                                }
2148                        }
2149                }
2150
2151                up = 0;
2152                dn = 0;
2153                m = 1;
2154                n = 3;
2155                result = 0;
2156                wait_count = 0;
2157        } else {
2158                /*accquire the BT TRx retry count from BT_Info byte2*/
2159                retry_count = coex_sta->bt_retry_cnt;
2160                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2161                          "[BTCoex], retry_count = %d\n", retry_count);
2162                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2163                          "[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n",
2164                          up, dn, m, n, wait_count);
2165                result = 0;
2166                wait_count++;
2167                 /* no retry in the last 2-second duration*/
2168                if (retry_count == 0) {
2169                        up++;
2170                        dn--;
2171
2172                        if (dn <= 0)
2173                                dn = 0;
2174
2175                        if (up >= n) {
2176                                wait_count = 0;
2177                                n = 3;
2178                                up = 0;
2179                                dn = 0;
2180                                result = 1;
2181                                BTC_PRINT(BTC_MSG_ALGORITHM,
2182                                          ALGO_TRACE_FW_DETAIL,
2183                                          "[BTCoex], Increase wifi "
2184                                          "duration!!\n");
2185                        } /* <=3 retry in the last 2-second duration*/
2186                } else if (retry_count <= 3) {
2187                        up--;
2188                        dn++;
2189
2190                        if (up <= 0)
2191                                up = 0;
2192
2193                        if (dn == 2) {
2194                                if (wait_count <= 2)
2195                                        m++;
2196                                else
2197                                        m = 1;
2198
2199                                if (m >= 20)
2200                                        m = 20;
2201
2202                                n = 3 * m;
2203                                up = 0;
2204                                dn = 0;
2205                                wait_count = 0;
2206                                result = -1;
2207                                BTC_PRINT(BTC_MSG_ALGORITHM,
2208                                          ALGO_TRACE_FW_DETAIL,
2209                                          "[BTCoex], Decrease wifi duration "
2210                                          "for retry_counter<3!!\n");
2211                        }
2212                } else {
2213                        if (wait_count == 1)
2214                                m++;
2215                        else
2216                                m = 1;
2217
2218                        if (m >= 20)
2219                                m = 20;
2220
2221                        n = 3 * m;
2222                        up = 0;
2223                        dn = 0;
2224                        wait_count = 0;
2225                        result = -1;
2226                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2227                                  "[BTCoex], Decrease wifi duration "
2228                                  "for retry_counter>3!!\n");
2229                }
2230
2231                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2232                          "[BTCoex], max Interval = %d\n", max_interval);
2233                if (max_interval == 1)
2234                        set_tdma_int1(btcoexist, tx_pause, result);
2235                else if (max_interval == 2)
2236                        set_tdma_int2(btcoexist, tx_pause, result);
2237                else if (max_interval == 3)
2238                        set_tdma_int3(btcoexist, tx_pause, result);
2239        }
2240
2241        /*if current PsTdma not match with the recorded one (when scan, dhcp..),
2242         *then we have to adjust it back to the previous recorded one.
2243         */
2244        if (coex_dm->cur_ps_tdma != coex_dm->tdma_adj_type) {
2245                bool scan = false, link = false, roam = false;
2246                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2247                          "[BTCoex], PsTdma type dismatch!!!, "
2248                          "curPsTdma=%d, recordPsTdma=%d\n",
2249                          coex_dm->cur_ps_tdma, coex_dm->tdma_adj_type);
2250
2251                btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
2252                btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
2253                btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
2254
2255                if (!scan && !link && !roam)
2256                        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true,
2257                                             coex_dm->tdma_adj_type);
2258                else
2259                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL,
2260                                  "[BTCoex], roaming/link/scan is under"
2261                                  " progress, will adjust next time!!!\n");
2262        }
2263}
2264
2265/* SCO only or SCO+PAN(HS) */
2266static void btc8723b2ant_action_sco(struct btc_coexist *btcoexist)
2267{
2268        u8 wifi_rssi_state;
2269        u32 wifi_bw;
2270
2271        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2272                                                       0, 2, 15, 0);
2273
2274        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2275
2276        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 4);
2277
2278        if (btc8723b_need_dec_pwr(btcoexist))
2279                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2280        else
2281                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2282
2283        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2284
2285        /*for SCO quality at 11b/g mode*/
2286        if (BTC_WIFI_BW_LEGACY == wifi_bw)
2287                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 2);
2288        else  /*for SCO quality & wifi performance balance at 11n mode*/
2289                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 8);
2290
2291        /*for voice quality */
2292        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 0);
2293
2294        /* sw mechanism */
2295        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2296                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2297                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2298                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2299                                                   false, false);
2300                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2301                                                   true, 0x4);
2302                } else {
2303                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2304                                                   false, false);
2305                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2306                                                   true, 0x4);
2307                }
2308        } else {
2309                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2310                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2311                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2312                                                   false, false);
2313                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2314                                                   true, 0x4);
2315                } else {
2316                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2317                                                   false, false);
2318                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2319                                                   true, 0x4);
2320                }
2321        }
2322}
2323
2324static void btc8723b2ant_action_hid(struct btc_coexist *btcoexist)
2325{
2326        u8 wifi_rssi_state, bt_rssi_state;
2327        u32 wifi_bw;
2328
2329        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2330                                                       0, 2, 15, 0);
2331        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2332
2333        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2334
2335        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2336
2337        if (btc8723b_need_dec_pwr(btcoexist))
2338                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2339        else
2340                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2341
2342        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2343
2344        if (BTC_WIFI_BW_LEGACY == wifi_bw) /*/for HID at 11b/g mode*/
2345                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2346        else  /*for HID quality & wifi performance balance at 11n mode*/
2347                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 9);
2348
2349        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2350            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2351                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 9);
2352        else
2353                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 13);
2354
2355        /* sw mechanism */
2356        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2357                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2358                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2359                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2360                                                   false, false);
2361                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2362                                                   false, 0x18);
2363                } else {
2364                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2365                                                   false, false);
2366                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2367                                                   false, 0x18);
2368                }
2369        } else {
2370                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2371                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2372                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2373                                                   false, false);
2374                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2375                                                   false, 0x18);
2376                } else {
2377                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2378                                                   false, false);
2379                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2380                                                   false, 0x18);
2381                }
2382        }
2383}
2384
2385/*A2DP only / PAN(EDR) only/ A2DP+PAN(HS)*/
2386static void btc8723b2ant_action_a2dp(struct btc_coexist *btcoexist)
2387{
2388        u8 wifi_rssi_state, bt_rssi_state;
2389        u32 wifi_bw;
2390
2391        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2392                                                       0, 2, 15, 0);
2393        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2394
2395        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2396
2397        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2398
2399        if (btc8723b_need_dec_pwr(btcoexist))
2400                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2401        else
2402                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2403
2404        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2405
2406        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2407            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2408                btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2409                                                  false, 1);
2410        else
2411                btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 1);
2412
2413        /* sw mechanism */
2414        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2415        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2416                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2417                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2418                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2419                                                   false, false);
2420                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2421                                                   false, 0x18);
2422                } else {
2423                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2424                                                   false, false);
2425                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2426                                                   false, 0x18);
2427                }
2428        } else {
2429                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2430                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2431                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2432                                                   false, false);
2433                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2434                                                   false, 0x18);
2435                } else {
2436                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2437                                                   false, false);
2438                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2439                                                   false, 0x18);
2440                }
2441        }
2442}
2443
2444static void btc8723b2ant_action_a2dp_pan_hs(struct btc_coexist *btcoexist)
2445{
2446        u8 wifi_rssi_state;
2447        u32 wifi_bw;
2448
2449        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2450                                                       0, 2, 15, 0);
2451
2452        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2453
2454        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2455
2456        if (btc8723b_need_dec_pwr(btcoexist))
2457                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2458        else
2459                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2460
2461        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2462
2463        btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 2);
2464
2465        /* sw mechanism */
2466        btcoexist->btc_get(btcoexist,
2467                BTC_GET_U4_WIFI_BW, &wifi_bw);
2468        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2469                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2470                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2471                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2472                                                   false, false);
2473                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2474                                                   false, 0x18);
2475                } else {
2476                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2477                                                   false, false);
2478                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2479                                                   false, 0x18);
2480                }
2481        } else {
2482                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2483                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2484                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2485                                                   false, false);
2486                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2487                                                   false, 0x18);
2488                } else {
2489                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2490                                                   false, false);
2491                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2492                                                   false, 0x18);
2493                }
2494        }
2495}
2496
2497static void btc8723b2ant_action_pan_edr(struct btc_coexist *btcoexist)
2498{
2499        u8 wifi_rssi_state, bt_rssi_state;
2500        u32 wifi_bw;
2501
2502        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2503                                                       0, 2, 15, 0);
2504        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2505
2506        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2507
2508        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2509
2510        if (btc8723b_need_dec_pwr(btcoexist))
2511                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2512        else
2513                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2514
2515        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 10);
2516
2517        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2518            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2519                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 1);
2520        else
2521                btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, true, 5);
2522
2523        /* sw mechanism */
2524        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2525        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2526                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2527                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2528                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2529                                                   false, false);
2530                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2531                                                   false, 0x18);
2532                } else {
2533                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2534                                                   false, false);
2535                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2536                                                   false, 0x18);
2537                }
2538        } else {
2539                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2540                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2541                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2542                                                   false, false);
2543                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2544                                                   false, 0x18);
2545                } else {
2546                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2547                                                   false, false);
2548                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2549                                                   false, 0x18);
2550                }
2551        }
2552}
2553
2554/*PAN(HS) only*/
2555static void btc8723b2ant_action_pan_hs(struct btc_coexist *btcoexist)
2556{
2557        u8 wifi_rssi_state;
2558        u32 wifi_bw;
2559
2560        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2561                                                       0, 2, 15, 0);
2562
2563        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2564
2565        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2566
2567        if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2568            (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2569                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2570        else
2571                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2572
2573        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2574
2575        btc8723b2ant_ps_tdma(btcoexist, NORMAL_EXEC, false, 1);
2576
2577        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2578        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2579                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2580                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2581                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2582                                                   false, false);
2583                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2584                                                   false, 0x18);
2585                } else {
2586                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2587                                                   false, false);
2588                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2589                                                   false, 0x18);
2590                }
2591        } else {
2592                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2593                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2594                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2595                                                   false, false);
2596                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2597                                                   false, 0x18);
2598                } else {
2599                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2600                                                   false, false);
2601                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2602                                                   false, 0x18);
2603                }
2604        }
2605}
2606
2607/*PAN(EDR)+A2DP*/
2608static void btc8723b2ant_action_pan_edr_a2dp(struct btc_coexist *btcoexist)
2609{
2610        u8 wifi_rssi_state, bt_rssi_state;
2611        u32 wifi_bw;
2612
2613        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2614                                                       0, 2, 15, 0);
2615        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2616
2617        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2618
2619        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2620
2621        if (btc8723b_need_dec_pwr(btcoexist))
2622                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2623        else
2624                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2625
2626        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2627
2628        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2629            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2630                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 12);
2631                if (BTC_WIFI_BW_HT40 == wifi_bw)
2632                        btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2633                                                          true, 3);
2634                else
2635                        btc8723b2ant_tdma_duration_adjust(btcoexist, false,
2636                                                          false, 3);
2637        } else {
2638                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2639                btc8723b2ant_tdma_duration_adjust(btcoexist, false, true, 3);
2640        }
2641
2642        /* sw mechanism */
2643        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2644                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2645                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2646                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2647                                                   false, false);
2648                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2649                                                   false, 0x18);
2650                } else {
2651                        btc8723b2ant_sw_mechanism1(btcoexist, true, false,
2652                                                   false, false);
2653                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2654                                                   false, 0x18);
2655                }
2656        } else {
2657                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2658                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2659                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2660                                                   false, false);
2661                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2662                                                   false, 0x18);
2663                } else {
2664                        btc8723b2ant_sw_mechanism1(btcoexist, false, false,
2665                                                   false, false);
2666                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2667                                                   false, 0x18);
2668                }
2669        }
2670}
2671
2672static void btc8723b2ant_action_pan_edr_hid(struct btc_coexist *btcoexist)
2673{
2674        u8 wifi_rssi_state, bt_rssi_state;
2675        u32 wifi_bw;
2676
2677        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2678                                                       0, 2, 15, 0);
2679        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2680        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2681
2682        if (btc8723b_need_dec_pwr(btcoexist))
2683                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2684        else
2685                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2686
2687        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2688            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2689                if (BTC_WIFI_BW_HT40 == wifi_bw) {
2690                        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2691                                                      3);
2692                        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2693                        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2694                                                  0xfffff, 0x780);
2695                } else {
2696                        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC,
2697                                                      6);
2698                        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2699                        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1,
2700                                                  0xfffff, 0x0);
2701                }
2702                btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2703        } else {
2704                btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2705                btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 11);
2706                btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff,
2707                                          0x0);
2708                btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2709        }
2710
2711        /* sw mechanism */
2712        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2713                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2714                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2715                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2716                                                   false, false);
2717                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2718                                                   false, 0x18);
2719                } else {
2720                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2721                                                   false, false);
2722                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2723                                                   false, 0x18);
2724                }
2725        } else {
2726                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2727                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2728                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2729                                                   false, false);
2730                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2731                                                   false, 0x18);
2732                } else {
2733                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2734                                                   false, false);
2735                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2736                                                   false, 0x18);
2737                }
2738        }
2739}
2740
2741/* HID+A2DP+PAN(EDR) */
2742static void btc8723b2ant_action_hid_a2dp_pan_edr(struct btc_coexist *btcoexist)
2743{
2744        u8 wifi_rssi_state, bt_rssi_state;
2745        u32 wifi_bw;
2746
2747        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2748                                                       0, 2, 15, 0);
2749        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2750
2751        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2752
2753        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2754
2755        if (btc8723b_need_dec_pwr(btcoexist))
2756                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2757        else
2758                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2759
2760        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2761
2762        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2763
2764        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2765            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2766                if (BTC_WIFI_BW_HT40 == wifi_bw)
2767                        btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2768                                                          true, 2);
2769                else
2770                        btc8723b2ant_tdma_duration_adjust(btcoexist, true,
2771                                                          false, 3);
2772        } else {
2773                btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 3);
2774        }
2775
2776        /* sw mechanism */
2777        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2778                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2779                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2780                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2781                                                   false, false);
2782                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2783                                                   false, 0x18);
2784                } else {
2785                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2786                                                   false, false);
2787                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2788                                                   false, 0x18);
2789                }
2790        } else {
2791                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2792                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2793                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2794                                                   false, false);
2795                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2796                                                   false, 0x18);
2797                } else {
2798                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2799                                                   false, false);
2800                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2801                                                   false, 0x18);
2802                }
2803        }
2804}
2805
2806static void btc8723b2ant_action_hid_a2dp(struct btc_coexist *btcoexist)
2807{
2808        u8 wifi_rssi_state, bt_rssi_state;
2809        u32 wifi_bw;
2810
2811        wifi_rssi_state = btc8723b2ant_wifi_rssi_state(btcoexist,
2812                                                          0, 2, 15, 0);
2813        bt_rssi_state = btc8723b2ant_bt_rssi_state(2, 35, 0);
2814
2815        btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2816
2817        btc8723b2ant_fw_dac_swing_lvl(btcoexist, NORMAL_EXEC, 6);
2818
2819        if (btc8723b_need_dec_pwr(btcoexist))
2820                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, true);
2821        else
2822                btc8723b2ant_dec_bt_pwr(btcoexist, NORMAL_EXEC, false);
2823
2824        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
2825
2826        btc8723b_coex_tbl_type(btcoexist, NORMAL_EXEC, 7);
2827
2828        if ((bt_rssi_state == BTC_RSSI_STATE_HIGH) ||
2829            (bt_rssi_state == BTC_RSSI_STATE_STAY_HIGH))
2830                btc8723b2ant_tdma_duration_adjust(btcoexist, true, false, 2);
2831        else
2832                btc8723b2ant_tdma_duration_adjust(btcoexist, true, true, 2);
2833
2834        /* sw mechanism */
2835        if (BTC_WIFI_BW_HT40 == wifi_bw) {
2836                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2837                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2838                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2839                                                   false, false);
2840                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2841                                                   false, 0x18);
2842                } else {
2843                        btc8723b2ant_sw_mechanism1(btcoexist, true, true,
2844                                                   false, false);
2845                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2846                                                   false, 0x18);
2847                }
2848        } else {
2849                if ((wifi_rssi_state == BTC_RSSI_STATE_HIGH) ||
2850                    (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH)) {
2851                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2852                                                   false, false);
2853                        btc8723b2ant_sw_mechanism2(btcoexist, true, false,
2854                                                   false, 0x18);
2855                } else {
2856                        btc8723b2ant_sw_mechanism1(btcoexist, false, true,
2857                                                   false, false);
2858                        btc8723b2ant_sw_mechanism2(btcoexist, false, false,
2859                                                   false, 0x18);
2860                }
2861        }
2862}
2863
2864static void btc8723b2ant_run_coexist_mechanism(struct btc_coexist *btcoexist)
2865{
2866        u8 algorithm = 0;
2867
2868        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2869                  "[BTCoex], RunCoexistMechanism()===>\n");
2870
2871        if (btcoexist->manual_control) {
2872                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2873                          "[BTCoex], RunCoexistMechanism(), "
2874                          "return for Manual CTRL <===\n");
2875                return;
2876        }
2877
2878        if (coex_sta->under_ips) {
2879                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2880                          "[BTCoex], wifi is under IPS !!!\n");
2881                return;
2882        }
2883
2884        algorithm = btc8723b2ant_action_algorithm(btcoexist);
2885        if (coex_sta->c2h_bt_inquiry_page &&
2886            (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
2887                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2888                          "[BTCoex], BT is under inquiry/page scan !!\n");
2889                btc8723b2ant_action_bt_inquiry(btcoexist);
2890                return;
2891        } else {
2892                if (coex_dm->need_recover_0x948) {
2893                        coex_dm->need_recover_0x948 = false;
2894                        btcoexist->btc_write_2byte(btcoexist, 0x948,
2895                                                   coex_dm->backup_0x948);
2896                }
2897        }
2898
2899        coex_dm->cur_algorithm = algorithm;
2900        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, "[BTCoex], Algorithm = %d\n",
2901                  coex_dm->cur_algorithm);
2902
2903        if (btc8723b2ant_is_common_action(btcoexist)) {
2904                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2905                          "[BTCoex], Action 2-Ant common.\n");
2906                coex_dm->auto_tdma_adjust = false;
2907        } else {
2908                if (coex_dm->cur_algorithm != coex_dm->pre_algorithm) {
2909                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2910                                  "[BTCoex], preAlgorithm=%d, "
2911                                  "curAlgorithm=%d\n", coex_dm->pre_algorithm,
2912                                  coex_dm->cur_algorithm);
2913                        coex_dm->auto_tdma_adjust = false;
2914                }
2915                switch (coex_dm->cur_algorithm) {
2916                case BT_8723B_2ANT_COEX_ALGO_SCO:
2917                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2918                                  "[BTCoex], Action 2-Ant, algorithm = SCO.\n");
2919                        btc8723b2ant_action_sco(btcoexist);
2920                        break;
2921                case BT_8723B_2ANT_COEX_ALGO_HID:
2922                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2923                                  "[BTCoex], Action 2-Ant, algorithm = HID.\n");
2924                        btc8723b2ant_action_hid(btcoexist);
2925                        break;
2926                case BT_8723B_2ANT_COEX_ALGO_A2DP:
2927                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2928                                  "[BTCoex], Action 2-Ant, "
2929                                  "algorithm = A2DP.\n");
2930                        btc8723b2ant_action_a2dp(btcoexist);
2931                        break;
2932                case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
2933                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2934                                  "[BTCoex], Action 2-Ant, "
2935                                  "algorithm = A2DP+PAN(HS).\n");
2936                        btc8723b2ant_action_a2dp_pan_hs(btcoexist);
2937                        break;
2938                case BT_8723B_2ANT_COEX_ALGO_PANEDR:
2939                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2940                                  "[BTCoex], Action 2-Ant, "
2941                                  "algorithm = PAN(EDR).\n");
2942                        btc8723b2ant_action_pan_edr(btcoexist);
2943                        break;
2944                case BT_8723B_2ANT_COEX_ALGO_PANHS:
2945                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2946                                  "[BTCoex], Action 2-Ant, "
2947                                  "algorithm = HS mode.\n");
2948                        btc8723b2ant_action_pan_hs(btcoexist);
2949                                break;
2950                case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
2951                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2952                                  "[BTCoex], Action 2-Ant, "
2953                                  "algorithm = PAN+A2DP.\n");
2954                        btc8723b2ant_action_pan_edr_a2dp(btcoexist);
2955                        break;
2956                case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
2957                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2958                                  "[BTCoex], Action 2-Ant, "
2959                                  "algorithm = PAN(EDR)+HID.\n");
2960                        btc8723b2ant_action_pan_edr_hid(btcoexist);
2961                        break;
2962                case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
2963                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2964                                  "[BTCoex], Action 2-Ant, "
2965                                  "algorithm = HID+A2DP+PAN.\n");
2966                        btc8723b2ant_action_hid_a2dp_pan_edr(btcoexist);
2967                        break;
2968                case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
2969                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2970                                  "[BTCoex], Action 2-Ant, "
2971                                  "algorithm = HID+A2DP.\n");
2972                        btc8723b2ant_action_hid_a2dp(btcoexist);
2973                        break;
2974                default:
2975                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
2976                                  "[BTCoex], Action 2-Ant, "
2977                                  "algorithm = coexist All Off!!\n");
2978                        btc8723b2ant_coex_alloff(btcoexist);
2979                        break;
2980                }
2981                coex_dm->pre_algorithm = coex_dm->cur_algorithm;
2982        }
2983}
2984
2985
2986
2987/*********************************************************************
2988 *  work around function start with wa_btc8723b2ant_
2989 *********************************************************************/
2990/*********************************************************************
2991 *  extern function start with EXbtc8723b2ant_
2992 *********************************************************************/
2993void ex_halbtc8723b2ant_init_hwconfig(struct btc_coexist *btcoexist)
2994{
2995        struct btc_board_info *board_info = &btcoexist->board_info;
2996        u32 u32tmp = 0, fw_ver;
2997        u8 u8tmp = 0;
2998        u8 h2c_parameter[2] = {0};
2999
3000

3001        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3002                  "[BTCoex], 2Ant Init HW Config!!\n");
3003
3004        /* backup rf 0x1e value */
3005        coex_dm->bt_rf0x1e_backup = btcoexist->btc_get_rf_reg(btcoexist,
3006                                                              BTC_RF_A, 0x1e,
3007                                                              0xfffff);
3008
3009        /* 0x4c[23]=0, 0x4c[24]=1  Antenna control by WL/BT */
3010        u32tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3011        u32tmp &= ~BIT23;
3012        u32tmp |= BIT24;
3013        btcoexist->btc_write_4byte(btcoexist, 0x4c, u32tmp);
3014
3015        btcoexist->btc_write_1byte(btcoexist, 0x974, 0xff);
3016        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x944, 0x3, 0x3);
3017        btcoexist->btc_write_1byte(btcoexist, 0x930, 0x77);
3018        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x67, 0x20, 0x1);
3019
3020        /* Antenna switch control parameter */
3021        /* btcoexist->btc_write_4byte(btcoexist, 0x858, 0x55555555);*/
3022
3023        /*Force GNT_BT to low*/
3024        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x765, 0x18, 0x0);
3025        btcoexist->btc_write_2byte(btcoexist, 0x948, 0x0);
3026
3027        /* 0x790[5:0]=0x5 */
3028        u8tmp = btcoexist->btc_read_1byte(btcoexist, 0x790);
3029        u8tmp &= 0xc0;
3030        u8tmp |= 0x5;
3031        btcoexist->btc_write_1byte(btcoexist, 0x790, u8tmp);
3032
3033
3034        /*Antenna config        */
3035        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3036
3037 /*ext switch for fw ver < 0xc */
3038        if (fw_ver < 0xc00) {
3039                if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
3040                        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
3041                                                           0x3, 0x1);
3042                        /*Main Ant to  BT for IPS case 0x4c[23]=1*/
3043                        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
3044                                                           0x1);
3045
3046                        /*tell firmware "no antenna inverse"*/
3047                        h2c_parameter[0] = 0;
3048                        h2c_parameter[1] = 1;  /* ext switch type */
3049                        btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
3050                                                h2c_parameter);
3051                } else {
3052                        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c,
3053                                                           0x3, 0x2);
3054                        /*Aux Ant to  BT for IPS case 0x4c[23]=1*/
3055                        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1,
3056                                                           0x0);
3057
3058                        /*tell firmware "antenna inverse"*/
3059                        h2c_parameter[0] = 1;
3060                        h2c_parameter[1] = 1;  /*ext switch type*/
3061                        btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
3062                                                h2c_parameter);
3063                }
3064        } else {
3065                /*ext switch always at s1 (if exist) */
3066                btcoexist->btc_write_1byte_bitmask(btcoexist, 0x92c, 0x3, 0x1);
3067                /*Main Ant to  BT for IPS case 0x4c[23]=1*/
3068                btcoexist->btc_write_1byte_bitmask(btcoexist, 0x64, 0x1, 0x1);
3069
3070                if (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT) {
3071                        /*tell firmware "no antenna inverse"*/
3072                        h2c_parameter[0] = 0;
3073                        h2c_parameter[1] = 0;  /*ext switch type*/
3074                        btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
3075                                                h2c_parameter);
3076                } else {
3077                        /*tell firmware "antenna inverse"*/
3078                        h2c_parameter[0] = 1;
3079                        h2c_parameter[1] = 0;  /*ext switch type*/
3080                        btcoexist->btc_fill_h2c(btcoexist, 0x65, 2,
3081                                                h2c_parameter);
3082                }
3083        }
3084
3085        /* PTA parameter */
3086        btc8723b_coex_tbl_type(btcoexist, FORCE_EXEC, 0);
3087
3088        /* Enable counter statistics */
3089        /*0x76e[3] =1, WLAN_Act control by PTA*/
3090        btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc);
3091        btcoexist->btc_write_1byte(btcoexist, 0x778, 0x3);
3092        btcoexist->btc_write_1byte_bitmask(btcoexist, 0x40, 0x20, 0x1);
3093}
3094
3095void ex_halbtc8723b2ant_init_coex_dm(struct btc_coexist *btcoexist)
3096{
3097        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3098                  "[BTCoex], Coex Mechanism Init!!\n");
3099        btc8723b2ant_init_coex_dm(btcoexist);
3100}
3101
3102void ex_halbtc8723b2ant_display_coex_info(struct btc_coexist *btcoexist)
3103{
3104        struct btc_board_info *board_info = &btcoexist->board_info;
3105        struct btc_stack_info *stack_info = &btcoexist->stack_info;
3106        struct btc_bt_link_info *bt_link_info = &btcoexist->bt_link_info;
3107        u8 *cli_buf = btcoexist->cli_buf;
3108        u8 u8tmp[4], i, bt_info_ext, ps_tdma_case = 0;
3109        u32 u32tmp[4];
3110        bool roam = false, scan = false;
3111        bool link = false, wifi_under_5g = false;
3112        bool bt_hs_on = false, wifi_busy = false;
3113        s32 wifi_rssi = 0, bt_hs_rssi = 0;
3114        u32 wifi_bw, wifi_traffic_dir, fa_ofdm, fa_cck;
3115        u8 wifi_dot11_chnl, wifi_hs_chnl;
3116        u32 fw_ver = 0, bt_patch_ver = 0;
3117
3118        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3119                   "\r\n ============[BT Coexist info]============");
3120        CL_PRINTF(cli_buf);
3121
3122        if (btcoexist->manual_control) {
3123                CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3124                           "\r\n ==========[Under Manual Control]============");
3125                CL_PRINTF(cli_buf);
3126                CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3127                           "\r\n ==========================================");
3128                CL_PRINTF(cli_buf);
3129        }
3130
3131        if (!board_info->bt_exist) {
3132                CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n BT not exists !!!");
3133                CL_PRINTF(cli_buf);
3134                return;
3135        }
3136
3137        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ",
3138                   "Ant PG number/ Ant mechanism:",
3139                   board_info->pg_ant_num, board_info->btdm_ant_num);
3140        CL_PRINTF(cli_buf);
3141
3142        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d",
3143                   "BT stack/ hci ext ver",
3144                   ((stack_info->profile_notified) ? "Yes" : "No"),
3145                   stack_info->hci_version);
3146        CL_PRINTF(cli_buf);
3147
3148        btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3149        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3150        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3151                   "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)",
3152                   "CoexVer/ FwVer/ PatchVer",
3153                   glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3154                   fw_ver, bt_patch_ver, bt_patch_ver);
3155        CL_PRINTF(cli_buf);
3156
3157        btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on);
3158        btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL,
3159                           &wifi_dot11_chnl);
3160        btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifi_hs_chnl);
3161
3162        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d(%d)",
3163                   "Dot11 channel / HsChnl(HsMode)",
3164                   wifi_dot11_chnl, wifi_hs_chnl, bt_hs_on);
3165        CL_PRINTF(cli_buf);
3166
3167        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ",
3168                   "H2C Wifi inform bt chnl Info", coex_dm->wifi_chnl_info[0],
3169                   coex_dm->wifi_chnl_info[1], coex_dm->wifi_chnl_info[2]);
3170        CL_PRINTF(cli_buf);
3171
3172        btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
3173        btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi);
3174        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
3175                   "Wifi rssi/ HS rssi", wifi_rssi, bt_hs_rssi);
3176        CL_PRINTF(cli_buf);
3177
3178        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan);
3179        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link);
3180        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam);
3181        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d ",
3182                   "Wifi link/ roam/ scan", link, roam, scan);
3183        CL_PRINTF(cli_buf);
3184
3185        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under_5g);
3186        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw);
3187        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3188        btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION,
3189                           &wifi_traffic_dir);
3190        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s/ %s ",
3191                   "Wifi status", (wifi_under_5g ? "5G" : "2.4G"),
3192                   ((BTC_WIFI_BW_LEGACY == wifi_bw) ? "Legacy" :
3193                   (((BTC_WIFI_BW_HT40 == wifi_bw) ? "HT40" : "HT20"))),
3194                   ((!wifi_busy) ? "idle" :
3195                   ((BTC_WIFI_TRAFFIC_TX == wifi_traffic_dir) ?
3196                   "uplink" : "downlink")));
3197        CL_PRINTF(cli_buf);
3198
3199        CL_PRINTF(cli_buf);
3200
3201        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d / %d",
3202                   "SCO/HID/PAN/A2DP",
3203                   bt_link_info->sco_exist, bt_link_info->hid_exist,
3204                   bt_link_info->pan_exist, bt_link_info->a2dp_exist);
3205        CL_PRINTF(cli_buf);
3206        btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO);
3207
3208        bt_info_ext = coex_sta->bt_info_ext;
3209        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
3210                   "BT Info A2DP rate",
3211                   (bt_info_ext&BIT0) ? "Basic rate" : "EDR rate");
3212        CL_PRINTF(cli_buf);
3213
3214        for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3215                if (coex_sta->bt_info_c2h_cnt[i]) {
3216                        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3217                                   "\r\n %-35s = %02x %02x %02x "
3218                                   "%02x %02x %02x %02x(%d)",
3219                                   glbt_info_src_8723b_2ant[i],
3220                                   coex_sta->bt_info_c2h[i][0],
3221                                   coex_sta->bt_info_c2h[i][1],
3222                                   coex_sta->bt_info_c2h[i][2],
3223                                   coex_sta->bt_info_c2h[i][3],
3224                                   coex_sta->bt_info_c2h[i][4],
3225                                   coex_sta->bt_info_c2h[i][5],
3226                                   coex_sta->bt_info_c2h[i][6],
3227                                   coex_sta->bt_info_c2h_cnt[i]);
3228                        CL_PRINTF(cli_buf);
3229                }
3230        }
3231
3232        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/%s",
3233                   "PS state, IPS/LPS",
3234                   ((coex_sta->under_ips ? "IPS ON" : "IPS OFF")),
3235                   ((coex_sta->under_lps ? "LPS ON" : "LPS OFF")));
3236        CL_PRINTF(cli_buf);
3237        btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3238
3239        /* Sw mechanism */
3240        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3241                   "\r\n %-35s", "============[Sw mechanism]============");
3242        CL_PRINTF(cli_buf);
3243        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d ",
3244                   "SM1[ShRf/ LpRA/ LimDig]", coex_dm->cur_rf_rx_lpf_shrink,
3245                   coex_dm->cur_low_penalty_ra, coex_dm->limited_dig);
3246        CL_PRINTF(cli_buf);
3247        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3248                   "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]",
3249                   coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off,
3250                   coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl);
3251        CL_PRINTF(cli_buf);
3252
3253        /* Fw mechanism */
3254        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3255                   "============[Fw mechanism]============");
3256        CL_PRINTF(cli_buf);
3257
3258        ps_tdma_case = coex_dm->cur_ps_tdma;
3259        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3260                   "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)",
3261                   "PS TDMA", coex_dm->ps_tdma_para[0],
3262                   coex_dm->ps_tdma_para[1], coex_dm->ps_tdma_para[2],
3263                   coex_dm->ps_tdma_para[3], coex_dm->ps_tdma_para[4],
3264                   ps_tdma_case, coex_dm->auto_tdma_adjust);
3265        CL_PRINTF(cli_buf);
3266
3267        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ",
3268                   "DecBtPwr/ IgnWlanAct", coex_dm->cur_dec_bt_pwr,
3269                   coex_dm->cur_ignore_wlan_act);
3270        CL_PRINTF(cli_buf);
3271
3272        /* Hw setting */
3273        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
3274                   "============[Hw setting]============");
3275        CL_PRINTF(cli_buf);
3276
3277        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x",
3278                   "RF-A, 0x1e initVal", coex_dm->bt_rf0x1e_backup);
3279        CL_PRINTF(cli_buf);
3280
3281        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778);
3282        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x880);
3283        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
3284                   "0x778/0x880[29:25]", u8tmp[0],
3285                   (u32tmp[0]&0x3e000000) >> 25);
3286        CL_PRINTF(cli_buf);
3287
3288        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x948);
3289        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x67);
3290        u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x765);
3291        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3292                   "0x948/ 0x67[5] / 0x765",
3293                   u32tmp[0], ((u8tmp[0]&0x20) >> 5), u8tmp[1]);
3294        CL_PRINTF(cli_buf);
3295
3296        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x92c);
3297        u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x930);
3298        u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x944);
3299        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3300                   "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]",
3301                   u32tmp[0]&0x3, u32tmp[1]&0xff, u32tmp[2]&0x3);
3302        CL_PRINTF(cli_buf);
3303
3304
3305        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x39);
3306        u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x40);
3307        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x4c);
3308        u8tmp[2] = btcoexist->btc_read_1byte(btcoexist, 0x64);
3309        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3310                   "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3311                   "0x38[11]/0x40/0x4c[24:23]/0x64[0]",
3312                   ((u8tmp[0] & 0x8)>>3), u8tmp[1],
3313                   ((u32tmp[0]&0x01800000)>>23), u8tmp[2]&0x1);
3314        CL_PRINTF(cli_buf);
3315
3316        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550);
3317        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522);
3318        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
3319                   "0x550(bcn ctrl)/0x522", u32tmp[0], u8tmp[0]);
3320        CL_PRINTF(cli_buf);
3321
3322        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50);
3323        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x49c);
3324        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
3325                   "0xc50(dig)/0x49c(null-drop)", u32tmp[0]&0xff, u8tmp[0]);
3326        CL_PRINTF(cli_buf);
3327
3328        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xda0);
3329        u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xda4);
3330        u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0xda8);
3331        u32tmp[3] = btcoexist->btc_read_4byte(btcoexist, 0xcf0);
3332
3333        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0xa5b);
3334        u8tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0xa5c);
3335
3336        fa_ofdm = ((u32tmp[0]&0xffff0000) >> 16) +
3337                  ((u32tmp[1]&0xffff0000) >> 16) +
3338                   (u32tmp[1] & 0xffff) +
3339                   (u32tmp[2] & 0xffff) +
3340                  ((u32tmp[3]&0xffff0000) >> 16) +
3341                   (u32tmp[3] & 0xffff);
3342        fa_cck = (u8tmp[0] << 8) + u8tmp[1];
3343
3344        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x",
3345                   "OFDM-CCA/OFDM-FA/CCK-FA",
3346                   u32tmp[0]&0xffff, fa_ofdm, fa_cck);
3347        CL_PRINTF(cli_buf);
3348
3349        u32tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0);
3350        u32tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4);
3351        u32tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8);
3352        u8tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc);
3353        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3354                   "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
3355                   "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)",
3356                   u32tmp[0], u32tmp[1], u32tmp[2], u8tmp[0]);
3357        CL_PRINTF(cli_buf);
3358
3359        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
3360                   "0x770(high-pri rx/tx)",
3361                   coex_sta->high_priority_rx, coex_sta->high_priority_tx);
3362        CL_PRINTF(cli_buf);
3363        CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
3364                   "0x774(low-pri rx/tx)", coex_sta->low_priority_rx,
3365                   coex_sta->low_priority_tx);
3366        CL_PRINTF(cli_buf);
3367#if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 1)
3368        btc8723b2ant_monitor_bt_ctr(btcoexist);
3369#endif
3370        btcoexist->btc_disp_dbg_msg(btcoexist,
3371        BTC_DBG_DISP_COEX_STATISTICS);
3372}
3373
3374
3375void ex_halbtc8723b2ant_ips_notify(struct btc_coexist *btcoexist, u8 type)
3376{
3377        if (BTC_IPS_ENTER == type) {
3378                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3379                          "[BTCoex], IPS ENTER notify\n");
3380                coex_sta->under_ips = true;
3381                btc8723b2ant_coex_alloff(btcoexist);
3382        } else if (BTC_IPS_LEAVE == type) {
3383                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3384                          "[BTCoex], IPS LEAVE notify\n");
3385                coex_sta->under_ips = false;
3386        }
3387}
3388
3389void ex_halbtc8723b2ant_lps_notify(struct btc_coexist *btcoexist, u8 type)
3390{
3391        if (BTC_LPS_ENABLE == type) {
3392                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3393                          "[BTCoex], LPS ENABLE notify\n");
3394                coex_sta->under_lps = true;
3395        } else if (BTC_LPS_DISABLE == type) {
3396                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3397                          "[BTCoex], LPS DISABLE notify\n");
3398                coex_sta->under_lps = false;
3399        }
3400}
3401
3402void ex_halbtc8723b2ant_scan_notify(struct btc_coexist *btcoexist, u8 type)
3403{
3404        if (BTC_SCAN_START == type)
3405                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3406                          "[BTCoex], SCAN START notify\n");
3407        else if (BTC_SCAN_FINISH == type)
3408                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3409                          "[BTCoex], SCAN FINISH notify\n");
3410}
3411
3412void ex_halbtc8723b2ant_connect_notify(struct btc_coexist *btcoexist, u8 type)
3413{
3414        if (BTC_ASSOCIATE_START == type)
3415                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3416                          "[BTCoex], CONNECT START notify\n");
3417        else if (BTC_ASSOCIATE_FINISH == type)
3418                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3419                          "[BTCoex], CONNECT FINISH notify\n");
3420}
3421
3422void btc8723b_med_stat_notify(struct btc_coexist *btcoexist,
3423                                            u8 type)
3424{
3425        u8 h2c_parameter[3] = {0};
3426        u32 wifi_bw;
3427        u8 wifi_central_chnl;
3428
3429        if (BTC_MEDIA_CONNECT == type)
3430                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3431                          "[BTCoex], MEDIA connect notify\n");
3432        else
3433                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3434                          "[BTCoex], MEDIA disconnect notify\n");
3435
3436        /* only 2.4G we need to inform bt the chnl mask */
3437        btcoexist->btc_get(btcoexist,
3438                BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
3439        if ((BTC_MEDIA_CONNECT == type) &&
3440            (wifi_central_chnl <= 14)) {
3441                h2c_parameter[0] = 0x1;
3442                h2c_parameter[1] = wifi_central_chnl;
3443                btcoexist->btc_get(btcoexist,
3444                        BTC_GET_U4_WIFI_BW, &wifi_bw);
3445                if (BTC_WIFI_BW_HT40 == wifi_bw)
3446                        h2c_parameter[2] = 0x30;
3447                else
3448                        h2c_parameter[2] = 0x20;
3449        }
3450
3451        coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
3452        coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
3453        coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
3454
3455        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC,
3456                  "[BTCoex], FW write 0x66=0x%x\n",
3457                  h2c_parameter[0] << 16 | h2c_parameter[1] << 8 |
3458                  h2c_parameter[2]);
3459
3460        btcoexist->btc_fill_h2c(btcoexist, 0x66, 3, h2c_parameter);
3461}
3462
3463void ex_halbtc8723b2ant_special_packet_notify(struct btc_coexist *btcoexist,
3464                                              u8 type)
3465{
3466        if (type == BTC_PACKET_DHCP)
3467                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3468                          "[BTCoex], DHCP Packet notify\n");
3469}
3470
3471void ex_halbtc8723b2ant_bt_info_notify(struct btc_coexist *btcoexist,
3472                                       u8 *tmpbuf, u8 length)
3473{
3474        u8 bt_info = 0;
3475        u8 i, rsp_source = 0;
3476        bool bt_busy = false, limited_dig = false;
3477        bool wifi_connected = false;
3478
3479        coex_sta->c2h_bt_info_req_sent = false;
3480
3481        rsp_source = tmpbuf[0]&0xf;
3482        if (rsp_source >= BT_INFO_SRC_8723B_2ANT_MAX)
3483                rsp_source = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3484        coex_sta->bt_info_c2h_cnt[rsp_source]++;
3485
3486        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3487                  "[BTCoex], Bt info[%d], length=%d, hex data=[",
3488                  rsp_source, length);
3489        for (i = 0; i < length; i++) {
3490                coex_sta->bt_info_c2h[rsp_source][i] = tmpbuf[i];
3491                if (i == 1)
3492                        bt_info = tmpbuf[i];
3493                if (i == length-1)
3494                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3495                                  "0x%02x]\n", tmpbuf[i]);
3496                else
3497                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3498                                  "0x%02x, ", tmpbuf[i]);
3499        }
3500
3501        if (btcoexist->manual_control) {
3502                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3503                          "[BTCoex], BtInfoNotify(), "
3504                          "return for Manual CTRL<===\n");
3505                return;
3506        }
3507
3508        if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rsp_source) {
3509                coex_sta->bt_retry_cnt =        /* [3:0]*/
3510                        coex_sta->bt_info_c2h[rsp_source][2] & 0xf;
3511
3512                coex_sta->bt_rssi =
3513                        coex_sta->bt_info_c2h[rsp_source][3] * 2 + 10;
3514
3515                coex_sta->bt_info_ext =
3516                        coex_sta->bt_info_c2h[rsp_source][4];
3517
3518                /* Here we need to resend some wifi info to BT
3519                 * because bt is reset and loss of the info.
3520                 */
3521                if ((coex_sta->bt_info_ext & BIT1)) {
3522                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3523                                  "[BTCoex], BT ext info bit1 check,"
3524                                  " send wifi BW&Chnl to BT!!\n");
3525                        btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED,
3526                                           &wifi_connected);
3527                        if (wifi_connected)
3528                                btc8723b_med_stat_notify(btcoexist,
3529                                                         BTC_MEDIA_CONNECT);
3530                        else
3531                                btc8723b_med_stat_notify(btcoexist,
3532                                                         BTC_MEDIA_DISCONNECT);
3533                }
3534
3535                if ((coex_sta->bt_info_ext & BIT3)) {
3536                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3537                                  "[BTCoex], BT ext info bit3 check, "
3538                                  "set BT NOT to ignore Wlan active!!\n");
3539                        btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC,
3540                                                     false);
3541                } else {
3542                        /* BT already NOT ignore Wlan active, do nothing here.*/
3543                }
3544#if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3545                if ((coex_sta->bt_info_ext & BIT4)) {
3546                        /* BT auto report already enabled, do nothing*/
3547                } else {
3548                        btc8723b2ant_bt_auto_report(btcoexist, FORCE_EXEC,
3549                                                    true);
3550                }
3551#endif
3552        }
3553
3554        /* check BIT2 first ==> check if bt is under inquiry or page scan*/
3555        if (bt_info & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3556                coex_sta->c2h_bt_inquiry_page = true;
3557        else
3558                coex_sta->c2h_bt_inquiry_page = false;
3559
3560        /* set link exist status*/
3561        if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3562                coex_sta->bt_link_exist = false;
3563                coex_sta->pan_exist = false;
3564                coex_sta->a2dp_exist = false;
3565                coex_sta->hid_exist = false;
3566                coex_sta->sco_exist = false;
3567        } else { /*  connection exists */
3568                coex_sta->bt_link_exist = true;
3569                if (bt_info & BT_INFO_8723B_2ANT_B_FTP)
3570                        coex_sta->pan_exist = true;
3571                else
3572                        coex_sta->pan_exist = false;
3573                if (bt_info & BT_INFO_8723B_2ANT_B_A2DP)
3574                        coex_sta->a2dp_exist = true;
3575                else
3576                        coex_sta->a2dp_exist = false;
3577                if (bt_info & BT_INFO_8723B_2ANT_B_HID)
3578                        coex_sta->hid_exist = true;
3579                else
3580                        coex_sta->hid_exist = false;
3581                if (bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3582                        coex_sta->sco_exist = true;
3583                else
3584                        coex_sta->sco_exist = false;
3585        }
3586
3587        btc8723b2ant_update_bt_link_info(btcoexist);
3588
3589        if (!(bt_info & BT_INFO_8723B_2ANT_B_CONNECTION)) {
3590                coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3591                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3592                          "[BTCoex], BtInfoNotify(), "
3593                          "BT Non-Connected idle!!!\n");
3594        /* connection exists but no busy */
3595        } else if (bt_info == BT_INFO_8723B_2ANT_B_CONNECTION) {
3596                coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3597                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3598                          "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
3599        } else if ((bt_info & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3600                   (bt_info & BT_INFO_8723B_2ANT_B_SCO_BUSY)) {
3601                coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3602                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3603                          "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
3604        } else if (bt_info & BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3605                coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3606                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3607                          "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
3608        } else {
3609                coex_dm->bt_status = BT_8723B_2ANT_BT_STATUS_MAX;
3610                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3611                          "[BTCoex], BtInfoNotify(), "
3612                          "BT Non-Defined state!!!\n");
3613        }
3614
3615        if ((BT_8723B_2ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) ||
3616            (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) ||
3617            (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status)) {
3618                bt_busy = true;
3619                limited_dig = true;
3620        } else {
3621                bt_busy = false;
3622                limited_dig = false;
3623        }
3624
3625        btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
3626
3627        coex_dm->limited_dig = limited_dig;
3628        btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig);
3629
3630        btc8723b2ant_run_coexist_mechanism(btcoexist);
3631}
3632
3633void ex_halbtc8723b2ant_stack_operation_notify(struct btc_coexist *btcoexist,
3634                                               u8 type)
3635{
3636        if (BTC_STACK_OP_INQ_PAGE_PAIR_START == type)
3637                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3638                          "[BTCoex],StackOP Inquiry/page/pair start notify\n");
3639        else if (BTC_STACK_OP_INQ_PAGE_PAIR_FINISH == type)
3640                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY,
3641                          "[BTCoex],StackOP Inquiry/page/pair finish notify\n");
3642}
3643
3644void ex_halbtc8723b2ant_halt_notify(struct btc_coexist *btcoexist)
3645{
3646        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, "[BTCoex], Halt notify\n");
3647
3648        btc8723b2ant_ignore_wlan_act(btcoexist, FORCE_EXEC, true);
3649        btc8723b_med_stat_notify(btcoexist, BTC_MEDIA_DISCONNECT);
3650}
3651
3652void ex_halbtc8723b2ant_periodical(struct btc_coexist *btcoexist)
3653{
3654        struct btc_board_info *board_info = &btcoexist->board_info;
3655        struct btc_stack_info *stack_info = &btcoexist->stack_info;
3656        static u8 dis_ver_info_cnt;
3657        u32 fw_ver = 0, bt_patch_ver = 0;
3658
3659        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE,
3660                  "[BTCoex], =========================="
3661                  "Periodical===========================\n");
3662
3663        if (dis_ver_info_cnt <= 5) {
3664                dis_ver_info_cnt += 1;
3665                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3666                          "[BTCoex], ****************************"
3667                          "************************************\n");
3668                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3669                          "[BTCoex], Ant PG Num/ Ant Mech/ "
3670                          "Ant Pos = %d/ %d/ %d\n", board_info->pg_ant_num,
3671                          board_info->btdm_ant_num, board_info->btdm_ant_pos);
3672                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3673                          "[BTCoex], BT stack/ hci ext ver = %s / %d\n",
3674                          ((stack_info->profile_notified) ? "Yes" : "No"),
3675                          stack_info->hci_version);
3676                btcoexist->btc_get(btcoexist, BTC_GET_U4_BT_PATCH_VER,
3677                                   &bt_patch_ver);
3678                btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3679                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3680                          "[BTCoex], CoexVer/ FwVer/ PatchVer = "
3681                          "%d_%x/ 0x%x/ 0x%x(%d)\n",
3682                          glcoex_ver_date_8723b_2ant, glcoex_ver_8723b_2ant,
3683                          fw_ver, bt_patch_ver, bt_patch_ver);
3684                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT,
3685                          "[BTCoex], *****************************"
3686                          "***********************************\n");
3687        }
3688
3689#if (BT_AUTO_REPORT_ONLY_8723B_2ANT == 0)
3690        btc8723b2ant_query_bt_info(btcoexist);
3691        btc8723b2ant_monitor_bt_ctr(btcoexist);
3692        btc8723b2ant_monitor_bt_enable_disable(btcoexist);
3693#else
3694        if (btc8723b2ant_is_wifi_status_changed(btcoexist) ||
3695            coex_dm->auto_tdma_adjust)
3696                btc8723b2ant_run_coexist_mechanism(btcoexist);
3697#endif
3698}
3699