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

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