drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c

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