drivers/net/wireless/rockchip_wlan/rtl8723bs/hal/OUTSRC/odm_PathDiv.c

   1 /******************************************************************************\r
   2  *\r
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.\r
   4  *                                        \r
   5  * This program is free software; you can redistribute it and/or modify it\r
   6  * under the terms of version 2 of the GNU General Public License as\r
   7  * published by the Free Software Foundation.\r
   8  *\r
   9  * This program is distributed in the hope that it will be useful, but WITHOUT\r
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r
  12  * more details.\r
  13  *\r
  14  * You should have received a copy of the GNU General Public License along with\r
  15  * this program; if not, write to the Free Software Foundation, Inc.,\r
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA\r
  17  *\r
  18  *\r
  19  ******************************************************************************/\r
  20 \r
  21 //============================================================\r
  22 // include files\r
  23 //============================================================\r
  24 #include "odm_precomp.h"\r
  25 \r
  26
  27 \r
  28 VOID
  29 odm_PathDiversityInit(
  30         IN      PVOID   pDM_VOID\r
  31 )
  32 {\r
  33 #if(DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
  34         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;\r
  35         if(!(pDM_Odm->SupportAbility & ODM_BB_PATH_DIV))
  36         {
  37                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV,ODM_DBG_LOUD,("Return: Not Support PathDiv\n"));
  38                 return;
  39         }
  40
  41 #if RTL8812A_SUPPORT
  42
  43         if(pDM_Odm->SupportICType & ODM_RTL8812)
  44                 ODM_PathDiversityInit_8812A(pDM_Odm);
  45 #endif
  46 #endif
  47 }
  48 \r
  49 #if(DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE))
  50 VOID
  51 odm_PathDiversity(
  52         IN      PVOID   pDM_VOID\r
  53 )
  54 {\r
  55         PDM_ODM_T               pDM_Odm = (PDM_ODM_T)pDM_VOID;\r
  56         if(!(pDM_Odm->SupportAbility & ODM_BB_PATH_DIV))
  57         {
  58                 ODM_RT_TRACE(pDM_Odm, ODM_COMP_PATH_DIV,ODM_DBG_LOUD,("Return: Not Support PathDiv\n"));
  59                 return;
  60         }
  61
  62 #if RTL8812A_SUPPORT
  63
  64         if(pDM_Odm->SupportICType & ODM_RTL8812)
  65                 ODM_PathDiversity_8812A(pDM_Odm);
  66 #endif
  67 }\r
  68 #endif  //(DM_ODM_SUPPORT_TYPE & (ODM_WIN|ODM_CE)) \r
  69 \r
  70 \r
  71
  72 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)\r
  73 //\r
  74 // 2011/12/02 MH Copy from MP oursrc for temporarily test.
  75 //\r
  76 \r
  77 BOOLEAN\r
  78 odm_IsConnected_92C(
  79         IN      PADAPTER        Adapter
  80 )
  81 {
  82         PRT_WLAN_STA    pEntry;
  83         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
  84         u4Byte          i;
  85         BOOLEAN         bConnected=FALSE;
  86
  87         if(pMgntInfo->mAssoc)
  88         {
  89                 bConnected = TRUE;
  90         }
  91         else
  92         {
  93                 for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
  94                 {
  95                         if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
  96                                 pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
  97                         else
  98                                 pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
  99
 100                         if(pEntry!=NULL)
 101                         {
 102                                 if(pEntry->bAssociated)
 103                                 {
 104                                         bConnected = TRUE;
 105                                         break;
 106                                 }
 107                         }
 108                         else
 109                         {
 110                                 break;
 111                         }
 112                 }
 113         }
 114         return  bConnected;
 115 }
 116 \r
 117 BOOLEAN
 118 ODM_PathDiversityBeforeLink92C(
 119         //IN    PADAPTER        Adapter
 120         IN              PDM_ODM_T               pDM_Odm
 121         )
 122 {
 123 #if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
 124         PADAPTER                Adapter = pDM_Odm->Adapter;
 125         HAL_DATA_TYPE*  pHalData = NULL;
 126         PMGNT_INFO              pMgntInfo = NULL;
 127         //pSWAT_T               pDM_SWAT_Table = &Adapter->DM_SWAT_Table;
 128         pPD_T                   pDM_PDTable = NULL;
 129
 130         s1Byte                  Score = 0;
 131         PRT_WLAN_BSS    pTmpBssDesc;
 132         PRT_WLAN_BSS    pTestBssDesc;
 133
 134         u1Byte                  target_chnl = 0;
 135         u1Byte                  index;
 136
 137         if (pDM_Odm->Adapter == NULL)  //For BSOD when plug/unplug fast.  //By YJ,120413
 138         {       // The ODM structure is not initialized.
 139                 return FALSE;
 140         }
 141         pHalData = GET_HAL_DATA(Adapter);
 142         pMgntInfo = &Adapter->MgntInfo;
 143         pDM_PDTable = &Adapter->DM_PDTable;
 144
 145         // Condition that does not need to use path diversity.
 146         if((!IS_92C_SERIAL(pHalData->VersionID)) || (pHalData->PathDivCfg!=1) || pMgntInfo->AntennaTest )
 147         {
 148                 RT_TRACE(COMP_INIT, DBG_LOUD,
 149                                 ("ODM_PathDiversityBeforeLink92C(): No PathDiv Mechanism before link.\n"));
 150                 return FALSE;
 151         }
 152
 153         // Since driver is going to set BB register, it shall check if there is another thread controlling BB/RF.
 154         PlatformAcquireSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 155         if(pHalData->eRFPowerState!=eRfOn || pMgntInfo->RFChangeInProgress || pMgntInfo->bMediaConnect)
 156         {
 157                 PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 158
 159                 RT_TRACE(COMP_INIT, DBG_LOUD,
 160                                 ("ODM_PathDiversityBeforeLink92C(): RFChangeInProgress(%x), eRFPowerState(%x)\n",
 161                                 pMgntInfo->RFChangeInProgress,
 162                                 pHalData->eRFPowerState));
 163
 164                 //pDM_SWAT_Table->SWAS_NoLink_State = 0;
 165                 pDM_PDTable->PathDiv_NoLink_State = 0;
 166
 167                 return FALSE;
 168         }
 169         else
 170         {
 171                 PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
 172         }
 173
 174         //1 Run AntDiv mechanism "Before Link" part.
 175         //if(pDM_SWAT_Table->SWAS_NoLink_State == 0)
 176         if(pDM_PDTable->PathDiv_NoLink_State == 0)
 177         {
 178                 //1 Prepare to do Scan again to check current antenna state.
 179
 180                 // Set check state to next step.
 181                 //pDM_SWAT_Table->SWAS_NoLink_State = 1;
 182                 pDM_PDTable->PathDiv_NoLink_State = 1;
 183
 184                 // Copy Current Scan list.
 185                 Adapter->MgntInfo.tmpNumBssDesc = pMgntInfo->NumBssDesc;
 186                 PlatformMoveMemory((PVOID)Adapter->MgntInfo.tmpbssDesc, (PVOID)pMgntInfo->bssDesc, sizeof(RT_WLAN_BSS)*MAX_BSS_DESC);
 187
 188                 // Switch Antenna to another one.
 189                 if(pDM_PDTable->DefaultRespPath == 0)
 190                 {
 191                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x05); // TRX path = PathB
 192                         odm_SetRespPath_92C(Adapter, 1);
 193                         pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
 194                         pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
 195                 }
 196                 else
 197                 {
 198                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x00); // TRX path = PathA
 199                         odm_SetRespPath_92C(Adapter, 0);
 200                         pDM_PDTable->OFDMTXPath = 0x0;
 201                         pDM_PDTable->CCKTXPath = 0x0;
 202                 }
 203 #if 0
 204
 205                 pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
 206                 pDM_SWAT_Table->CurAntenna = (pDM_SWAT_Table->CurAntenna==Antenna_A)?Antenna_B:Antenna_A;
 207
 208                 RT_TRACE(COMP_INIT, DBG_LOUD,
 209                         ("ODM_SwAntDivCheckBeforeLink: Change to Ant(%s) for testing.\n", (pDM_SWAT_Table->CurAntenna==Antenna_A)?"A":"B"));
 210                 //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
 211                 pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
 212                 PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
 213 #endif
 214
 215                 // Go back to scan function again.
 216                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Scan one more time\n"));
 217                 pMgntInfo->ScanStep=0;
 218                 target_chnl = odm_SwAntDivSelectScanChnl(Adapter);
 219                 odm_SwAntDivConstructScanChnl(Adapter, target_chnl);
 220                 PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
 221
 222                 return TRUE;
 223         }
 224         else
 225         {
 226                 //1 ScanComple() is called after antenna swiched.
 227                 //1 Check scan result and determine which antenna is going
 228                 //1 to be used.
 229
 230                 for(index=0; index<Adapter->MgntInfo.tmpNumBssDesc; index++)
 231                 {
 232                         pTmpBssDesc = &(Adapter->MgntInfo.tmpbssDesc[index]);
 233                         pTestBssDesc = &(pMgntInfo->bssDesc[index]);
 234
 235                         if(PlatformCompareMemory(pTestBssDesc->bdBssIdBuf, pTmpBssDesc->bdBssIdBuf, 6)!=0)
 236                         {
 237                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C(): ERROR!! This shall not happen.\n"));
 238                                 continue;
 239                         }
 240
 241                         if(pTmpBssDesc->RecvSignalPower > pTestBssDesc->RecvSignalPower)
 242                         {
 243                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score++\n"));
 244                                 RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
 245                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
 246
 247                                 Score++;
 248                                 PlatformMoveMemory(pTestBssDesc, pTmpBssDesc, sizeof(RT_WLAN_BSS));
 249                         }
 250                         else if(pTmpBssDesc->RecvSignalPower < pTestBssDesc->RecvSignalPower)
 251                         {
 252                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score--\n"));
 253                                 RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
 254                                 RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
 255                                 Score--;
 256                         }
 257
 258                 }
 259
 260                 if(pMgntInfo->NumBssDesc!=0 && Score<=0)
 261                 {
 262                         RT_TRACE(COMP_INIT, DBG_LOUD,
 263                                 ("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
 264
 265                         //pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
 266                 }
 267                 else
 268                 {
 269                         RT_TRACE(COMP_INIT, DBG_LOUD,
 270                                 ("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
 271
 272                         if(pDM_PDTable->DefaultRespPath == 0)
 273                         {
 274                                 pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
 275                                 pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
 276                                 odm_SetRespPath_92C(Adapter, 1);
 277                         }
 278                         else
 279                         {
 280                                 pDM_PDTable->OFDMTXPath = 0x0;
 281                                 pDM_PDTable->CCKTXPath = 0x0;
 282                                 odm_SetRespPath_92C(Adapter, 0);
 283                         }
 284                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x01); // RX path = PathAB
 285
 286                         //pDM_SWAT_Table->CurAntenna = pDM_SWAT_Table->PreAntenna;
 287
 288                         //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
 289                         //pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
 290                         //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
 291                 }
 292
 293                 // Check state reset to default and wait for next time.
 294                 //pDM_SWAT_Table->SWAS_NoLink_State = 0;
 295                 pDM_PDTable->PathDiv_NoLink_State = 0;
 296
 297                 return FALSE;
 298         }
 299 #else
 300                 return  FALSE;
 301 #endif
 302
 303 }
 304
 305
 306
 307 VOID
 308 odm_PathDiversityAfterLink_92C(
 309         IN      PADAPTER        Adapter
 310 )
 311 {
 312         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
 313         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
 314         pPD_T           pDM_PDTable = &Adapter->DM_PDTable;
 315         u1Byte          DefaultRespPath=0;
 316
 317         if((!IS_92C_SERIAL(pHalData->VersionID)) || (pHalData->PathDivCfg != 1) || (pHalData->eRFPowerState == eRfOff))
 318         {
 319                 if(pHalData->PathDivCfg == 0)
 320                 {
 321                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("No ODM_TXPathDiversity()\n"));
 322                 }
 323                 else
 324                 {
 325                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("2T ODM_TXPathDiversity()\n"));
 326                 }
 327                 return;
 328         }
 329         if(!odm_IsConnected_92C(Adapter))
 330         {
 331                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity(): No Connections\n"));
 332                 return;
 333         }
 334
 335
 336         if(pDM_PDTable->TrainingState == 0)
 337         {
 338                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() ==>\n"));
 339                 odm_OFDMTXPathDiversity_92C(Adapter);
 340
 341                 if((pDM_PDTable->CCKPathDivEnable == TRUE) && (pDM_PDTable->OFDM_Pkt_Cnt < 100))
 342                 {
 343                         //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=0\n"));
 344
 345                         if(pDM_PDTable->CCK_Pkt_Cnt > 300)
 346                                 pDM_PDTable->Timer = 20;
 347                         else if(pDM_PDTable->CCK_Pkt_Cnt > 100)
 348                                 pDM_PDTable->Timer = 60;
 349                         else
 350                                 pDM_PDTable->Timer = 250;
 351                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: timer=%d\n",pDM_PDTable->Timer));
 352
 353                         PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x00); // RX path = PathA
 354                         pDM_PDTable->TrainingState = 1;
 355                         pHalData->RSSI_test = TRUE;
 356                         ODM_SetTimer( pDM_Odm, &pDM_Odm->CCKPathDiversityTimer, pDM_PDTable->Timer); //ms
 357                 }
 358                 else
 359                 {
 360                         pDM_PDTable->CCKTXPath = pDM_PDTable->OFDMTXPath;
 361                         DefaultRespPath = pDM_PDTable->OFDMDefaultRespPath;
 362                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: Skip odm_CCKTXPathDiversity_92C, DefaultRespPath is OFDM\n"));
 363                         odm_SetRespPath_92C(Adapter, DefaultRespPath);
 364                         odm_ResetPathDiversity_92C(Adapter);
 365                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() <==\n"));
 366                 }
 367         }
 368         else if(pDM_PDTable->TrainingState == 1)
 369         {
 370                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=1\n"));\r
 371                 PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x05); // RX path = PathB
 372                 pDM_PDTable->TrainingState = 2;
 373                 ODM_SetTimer( pDM_Odm, &pDM_Odm->CCKPathDiversityTimer, pDM_PDTable->Timer); //ms
 374         }
 375         else
 376         {
 377                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: TrainingState=2\n"));\r
 378                 pDM_PDTable->TrainingState = 0;
 379                 odm_CCKTXPathDiversity_92C(Adapter);
 380                 if(pDM_PDTable->OFDM_Pkt_Cnt != 0)
 381                 {
 382                         DefaultRespPath = pDM_PDTable->OFDMDefaultRespPath;
 383                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: DefaultRespPath is OFDM\n"));
 384                 }
 385                 else
 386                 {
 387                         DefaultRespPath = pDM_PDTable->CCKDefaultRespPath;
 388                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: DefaultRespPath is CCK\n"));
 389                 }
 390                 odm_SetRespPath_92C(Adapter, DefaultRespPath);
 391                 odm_ResetPathDiversity_92C(Adapter);
 392                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("ODM_TXPathDiversity() <==\n"));
 393         }
 394
 395 }
 396 \r
 397 VOID
 398 odm_SetRespPath_92C(
 399         IN      PADAPTER        Adapter,
 400         IN      u1Byte  DefaultRespPath
 401         )
 402 {
 403         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
 404
 405         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_SetRespPath_92C: Select Response Path=%d\n",DefaultRespPath));
 406         if(DefaultRespPath != pDM_PDTable->DefaultRespPath)
 407         {
 408                 if(DefaultRespPath == 0)
 409                 {
 410                         PlatformEFIOWrite1Byte(Adapter, 0x6D8, (PlatformEFIORead1Byte(Adapter, 0x6D8)&0xc0)|0x15);
 411                 }
 412                 else
 413                 {
 414                         PlatformEFIOWrite1Byte(Adapter, 0x6D8, (PlatformEFIORead1Byte(Adapter, 0x6D8)&0xc0)|0x2A);
 415                 }
 416         }
 417         pDM_PDTable->DefaultRespPath = DefaultRespPath;
 418 }\r
 419 \r
 420 VOID
 421 odm_OFDMTXPathDiversity_92C(
 422         IN      PADAPTER        Adapter)
 423 {
 424 //      HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
 425         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
 426         PRT_WLAN_STA    pEntry;
 427         u1Byte  i, DefaultRespPath = 0;
 428         s4Byte  MinRSSI = 0xFF;
 429         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
 430         pDM_PDTable->OFDMTXPath = 0;
 431
 432         //1 Default Port
 433         if(pMgntInfo->mAssoc)
 434         {
 435                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port RSSI[0]=%d, RSSI[1]=%d\n",
 436                         Adapter->RxStats.RxRSSIPercentage[0], Adapter->RxStats.RxRSSIPercentage[1]));
 437                 if(Adapter->RxStats.RxRSSIPercentage[0] > Adapter->RxStats.RxRSSIPercentage[1])
 438                 {
 439                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & (~BIT0);
 440                         MinRSSI =  Adapter->RxStats.RxRSSIPercentage[1];
 441                         DefaultRespPath = 0;
 442                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-0\n"));
 443                 }
 444                 else
 445                 {
 446                         pDM_PDTable->OFDMTXPath =  pDM_PDTable->OFDMTXPath | BIT0;
 447                         MinRSSI =  Adapter->RxStats.RxRSSIPercentage[0];
 448                         DefaultRespPath = 1;
 449                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-1\n"));
 450                 }
 451                         //RT_TRACE(     COMP_INIT, DBG_LOUD, ("pDM_PDTable->OFDMTXPath =0x%x\n",pDM_PDTable->OFDMTXPath));\r
 452         }
 453         //1 Extension Port
 454         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
 455         {
 456                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
 457                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
 458                 else
 459                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
 460
 461                 if(pEntry!=NULL)
 462                 {
 463                         if(pEntry->bAssociated)
 464                         {
 465                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d, RSSI_0=%d, RSSI_1=%d\n",
 466                                         pEntry->AssociatedMacId, pEntry->rssi_stat.RxRSSIPercentage[0], pEntry->rssi_stat.RxRSSIPercentage[1]));
 467
 468                                 if(pEntry->rssi_stat.RxRSSIPercentage[0] > pEntry->rssi_stat.RxRSSIPercentage[1])
 469                                 {
 470                                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & ~(BIT(pEntry->AssociatedMacId));
 471                                         //pHalData->TXPath = pHalData->TXPath & ~(1<<(pEntry->AssociatedMacId));
 472                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-0\n", pEntry->AssociatedMacId));
 473                                         if(pEntry->rssi_stat.RxRSSIPercentage[1] < MinRSSI)
 474                                         {
 475                                                 MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[1];
 476                                                 DefaultRespPath = 0;
 477                                         }
 478                                 }
 479                                 else
 480                                 {
 481                                         pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath | BIT(pEntry->AssociatedMacId);
 482                                         //pHalData->TXPath = pHalData->TXPath | (1 << (pEntry->AssociatedMacId));
 483                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-1\n", pEntry->AssociatedMacId));
 484                                         if(pEntry->rssi_stat.RxRSSIPercentage[0] < MinRSSI)
 485                                         {
 486                                                 MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[0];
 487                                                 DefaultRespPath = 1;
 488                                         }
 489                                 }
 490                         }
 491                 }
 492                 else
 493                 {
 494                         break;
 495                 }
 496         }
 497
 498         pDM_PDTable->OFDMDefaultRespPath = DefaultRespPath;
 499 }
 500 \r
 501 \r
 502 VOID
 503 odm_CCKTXPathDiversity_92C(
 504         IN      PADAPTER        Adapter
 505 )
 506 {
 507         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(Adapter);
 508         PMGNT_INFO              pMgntInfo = &(Adapter->MgntInfo);
 509         PRT_WLAN_STA    pEntry;
 510         s4Byte  MinRSSI = 0xFF;
 511         u1Byte  i, DefaultRespPath = 0;
 512 //      BOOLEAN bBModePathDiv = FALSE;
 513         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
 514
 515         //1 Default Port
 516         if(pMgntInfo->mAssoc)
 517         {
 518                 if(pHalData->OFDM_Pkt_Cnt == 0)
 519                 {
 520                         for(i=0; i<2; i++)
 521                         {
 522                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[i] > 1) //Because the first packet is discarded
 523                                         pDM_PDTable->RSSI_CCK_Path[i] = pDM_PDTable->RSSI_CCK_Path[i] / (pDM_PDTable->RSSI_CCK_Path_cnt[i]-1);
 524                                 else
 525                                         pDM_PDTable->RSSI_CCK_Path[i] = 0;
 526                         }
 527                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: pDM_PDTable->RSSI_CCK_Path[0]=%d, pDM_PDTable->RSSI_CCK_Path[1]=%d\n",
 528                                 pDM_PDTable->RSSI_CCK_Path[0], pDM_PDTable->RSSI_CCK_Path[1]));
 529                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: pDM_PDTable->RSSI_CCK_Path_cnt[0]=%d, pDM_PDTable->RSSI_CCK_Path_cnt[1]=%d\n",
 530                                 pDM_PDTable->RSSI_CCK_Path_cnt[0], pDM_PDTable->RSSI_CCK_Path_cnt[1]));
 531
 532                         if(pDM_PDTable->RSSI_CCK_Path[0] > pDM_PDTable->RSSI_CCK_Path[1])
 533                         {
 534                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
 535                                 MinRSSI =  pDM_PDTable->RSSI_CCK_Path[1];
 536                                 DefaultRespPath = 0;
 537                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
 538                         }
 539                         else if(pDM_PDTable->RSSI_CCK_Path[0] < pDM_PDTable->RSSI_CCK_Path[1])
 540                         {
 541                                 pDM_PDTable->CCKTXPath =  pDM_PDTable->CCKTXPath | BIT0;
 542                                 MinRSSI =  pDM_PDTable->RSSI_CCK_Path[0];
 543                                 DefaultRespPath = 1;
 544                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-1\n"));
 545                         }
 546                         else
 547                         {
 548                                 if((pDM_PDTable->RSSI_CCK_Path[0] != 0) && (pDM_PDTable->RSSI_CCK_Path[0] < MinRSSI))
 549                                 {
 550                                         pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
 551                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
 552                                         MinRSSI =  pDM_PDTable->RSSI_CCK_Path[1];
 553                                         DefaultRespPath = 0;
 554                                 }
 555                                 else
 556                                 {
 557                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port unchange CCK Path\n"));
 558                                 }
 559                         }
 560                 }
 561                 else //Follow OFDM decision
 562                 {
 563                         pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~BIT0)) | (pDM_PDTable->OFDMTXPath &BIT0);
 564                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, Default port Select CCK Path-%d\n",
 565                                 pDM_PDTable->CCKTXPath &BIT0));
 566                 }
 567         }
 568         //1 Extension Port
 569         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
 570         {
 571                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
 572                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
 573                 else
 574                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
 575
 576                 if(pEntry!=NULL)
 577                 {
 578                         if(pEntry->bAssociated)
 579                         {
 580                                 if(pEntry->rssi_stat.OFDM_Pkt_Cnt == 0)
 581                                 {
 582                                         u1Byte j=0;
 583                                         for(j=0; j<2; j++)
 584                                         {
 585                                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[j] > 1)
 586                                                         pEntry->rssi_stat.RSSI_CCK_Path[j] = pEntry->rssi_stat.RSSI_CCK_Path[j] / (pEntry->rssi_stat.RSSI_CCK_Path_cnt[j]-1);
 587                                                 else
 588                                                         pEntry->rssi_stat.RSSI_CCK_Path[j] = 0;
 589                                         }
 590                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d, RSSI_CCK0=%d, RSSI_CCK1=%d\n",
 591                                                 pEntry->AssociatedMacId, pEntry->rssi_stat.RSSI_CCK_Path[0], pEntry->rssi_stat.RSSI_CCK_Path[1]));
 592
 593                                         if(pEntry->rssi_stat.RSSI_CCK_Path[0] >pEntry->rssi_stat.RSSI_CCK_Path[1])
 594                                         {
 595                                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
 596                                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
 597                                                 if(pEntry->rssi_stat.RSSI_CCK_Path[1] < MinRSSI)
 598                                                 {
 599                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
 600                                                         DefaultRespPath = 0;
 601                                                 }
 602                                         }
 603                                         else if(pEntry->rssi_stat.RSSI_CCK_Path[0] <pEntry->rssi_stat.RSSI_CCK_Path[1])
 604                                         {
 605                                                 pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath | BIT(pEntry->AssociatedMacId);
 606                                                 RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-1\n", pEntry->AssociatedMacId));
 607                                                 if(pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI)
 608                                                 {
 609                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[0];
 610                                                         DefaultRespPath = 1;
 611                                                 }
 612                                         }
 613                                         else
 614                                         {
 615                                                 if((pEntry->rssi_stat.RSSI_CCK_Path[0] != 0) && (pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI))
 616                                                 {
 617                                                         pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
 618                                                         MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
 619                                                         DefaultRespPath = 0;
 620                                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
 621                                                 }
 622                                                 else
 623                                                 {
 624                                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d unchange CCK Path\n", pEntry->AssociatedMacId));
 625                                                 }
 626                                         }
 627                                 }
 628                                 else //Follow OFDM decision
 629                                 {
 630                                         pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~(BIT(pEntry->AssociatedMacId)))) | (pDM_PDTable->OFDMTXPath & BIT(pEntry->AssociatedMacId));
 631                                         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, MACID=%d Select CCK Path-%d\n",
 632                                                 pEntry->AssociatedMacId, (pDM_PDTable->CCKTXPath & BIT(pEntry->AssociatedMacId))>>(pEntry->AssociatedMacId)));
 633                                 }
 634                         }
 635                 }
 636                 else
 637                 {
 638                         break;
 639                 }
 640         }
 641
 642         RT_TRACE(       COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C:MinRSSI=%d\n",MinRSSI));
 643
 644         if(MinRSSI == 0xFF)
 645                 DefaultRespPath = pDM_PDTable->CCKDefaultRespPath;
 646
 647         pDM_PDTable->CCKDefaultRespPath = DefaultRespPath;
 648 }
 649 \r
 650 \r
 651 VOID
 652 odm_ResetPathDiversity_92C(
 653                 IN      PADAPTER        Adapter
 654 )
 655 {
 656         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
 657         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
 658         PRT_WLAN_STA    pEntry;
 659         u4Byte  i,j;
 660
 661         pHalData->RSSI_test = FALSE;
 662         pDM_PDTable->CCK_Pkt_Cnt = 0;
 663         pDM_PDTable->OFDM_Pkt_Cnt = 0;
 664         pHalData->CCK_Pkt_Cnt =0;
 665         pHalData->OFDM_Pkt_Cnt =0;
 666
 667         if(pDM_PDTable->CCKPathDivEnable == TRUE)
 668                 PHY_SetBBReg(Adapter, rCCK0_AFESetting  , 0x0F000000, 0x01); //RX path = PathAB
 669
 670         for(i=0; i<2; i++)
 671         {
 672                 pDM_PDTable->RSSI_CCK_Path_cnt[i]=0;
 673                 pDM_PDTable->RSSI_CCK_Path[i] = 0;
 674         }
 675         for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
 676         {
 677                 if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
 678                         pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
 679                 else
 680                         pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
 681
 682                 if(pEntry!=NULL)
 683                 {
 684                         pEntry->rssi_stat.CCK_Pkt_Cnt = 0;
 685                         pEntry->rssi_stat.OFDM_Pkt_Cnt = 0;
 686                         for(j=0; j<2; j++)
 687                         {
 688                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[j] = 0;
 689                                 pEntry->rssi_stat.RSSI_CCK_Path[j] = 0;
 690                         }
 691                 }
 692                 else
 693                         break;
 694         }
 695 }
 696
 697
 698
 699
 700
 701 VOID
 702 odm_CCKTXPathDiversityCallback(
 703         PRT_TIMER               pTimer
 704 )
 705 {
 706 #if USE_WORKITEM
 707        PADAPTER Adapter = (PADAPTER)pTimer->Adapter;
 708        HAL_DATA_TYPE    *pHalData = GET_HAL_DATA(Adapter);
 709            PDM_ODM_T            pDM_Odm = &pHalData->DM_OutSrc;
 710 #else
 711         PADAPTER        Adapter = (PADAPTER)pTimer->Adapter;
 712 #endif
 713
 714 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
 715 #if USE_WORKITEM
 716         PlatformScheduleWorkItem(&pDM_Odm->CCKPathDiversityWorkitem);
 717 #else
 718         odm_PathDiversityAfterLink_92C(Adapter);
 719 #endif
 720 #else
 721         PlatformScheduleWorkItem(&pDM_Odm->CCKPathDiversityWorkitem);
 722 #endif
 723
 724 }
 725
 726
 727 VOID
 728 odm_CCKTXPathDiversityWorkItemCallback(
 729     IN PVOID            pContext
 730     )
 731 {
 732         PADAPTER        Adapter = (PADAPTER)pContext;
 733
 734         odm_CCKTXPathDiversity_92C(Adapter);
 735 }
 736
 737 //
 738 // 20100514 Luke/Joseph:
 739 // Callback function for 500ms antenna test trying.
 740 //
 741 VOID
 742 odm_PathDivChkAntSwitchCallback(
 743         PRT_TIMER               pTimer
 744 )
 745 {
 746         PADAPTER                Adapter = (PADAPTER)pTimer->Adapter;
 747         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
 748         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
 749
 750 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
 751
 752 #if USE_WORKITEM
 753         PlatformScheduleWorkItem(&pDM_Odm->PathDivSwitchWorkitem);
 754 #else
 755         odm_PathDivChkAntSwitch(pDM_Odm);
 756 #endif
 757 #else
 758         PlatformScheduleWorkItem(&pDM_Odm->PathDivSwitchWorkitem);
 759 #endif
 760
 761 //odm_SwAntDivChkAntSwitch(Adapter, SWAW_STEP_DETERMINE);
 762
 763 }
 764
 765
 766 VOID
 767 odm_PathDivChkAntSwitchWorkitemCallback(
 768     IN PVOID            pContext
 769     )
 770 {
 771         PADAPTER        pAdapter = (PADAPTER)pContext;
 772         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 773         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
 774
 775         odm_PathDivChkAntSwitch(pDM_Odm);
 776 }\r
 777 \r
 778 \r
 779  //MAC0_ACCESS_PHY1
 780
 781 // 2011-06-22 Neil Chen & Gary Hsin
 782 // Refer to Jr.Luke's SW ANT DIV
 783 // 92D Path Diversity Main function
 784 // refer to 88C software antenna diversity
 785 //
 786 VOID
 787 odm_PathDivChkAntSwitch(
 788         PDM_ODM_T               pDM_Odm
 789         //PADAPTER              Adapter,
 790         //u1Byte                        Step
 791 )
 792 {
 793         PADAPTER                Adapter = pDM_Odm->Adapter;
 794         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
 795         PMGNT_INFO              pMgntInfo = &Adapter->MgntInfo;
 796
 797
 798         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
 799         s4Byte                  curRSSI=100, RSSI_A, RSSI_B;
 800         u1Byte                  nextAntenna=AUX_ANT;
 801         static u8Byte           lastTxOkCnt=0, lastRxOkCnt=0;
 802         u8Byte                  curTxOkCnt, curRxOkCnt;
 803         static u8Byte           TXByteCnt_A=0, TXByteCnt_B=0, RXByteCnt_A=0, RXByteCnt_B=0;
 804         u8Byte                  CurByteCnt=0, PreByteCnt=0;
 805         static u1Byte           TrafficLoad = TRAFFIC_LOW;
 806         u1Byte                  Score_A=0, Score_B=0;
 807         u1Byte                  i=0x0;
 808        // Neil Chen
 809        static u1Byte        pathdiv_para=0x0;
 810        static u1Byte        switchfirsttime=0x00;
 811         // u1Byte                 regB33 = (u1Byte) PHY_QueryBBReg(Adapter, 0xB30,BIT27);
 812         u1Byte                  regB33 = (u1Byte)ODM_GetBBReg(pDM_Odm, PATHDIV_REG, BIT27);
 813
 814
 815        //u1Byte                 reg637 =0x0;
 816        static u1Byte        fw_value=0x0;
 817         //u8Byte                        curTxOkCnt_tmp, curRxOkCnt_tmp;
 818        PADAPTER            BuddyAdapter = Adapter->BuddyAdapter;     // another adapter MAC
 819         // Path Diversity   //Neil Chen--2011--06--22
 820
 821         //u1Byte                 PathDiv_Trigger = (u1Byte) PHY_QueryBBReg(Adapter, 0xBA0,BIT31);
 822         u1Byte                 PathDiv_Trigger = (u1Byte) ODM_GetBBReg(pDM_Odm, PATHDIV_TRI,BIT31);
 823         u1Byte                 PathDiv_Enable = pHalData->bPathDiv_Enable;
 824
 825
 826         //DbgPrint("Path Div PG Value:%x \n",PathDiv_Enable);
 827        if((BuddyAdapter==NULL)||(!PathDiv_Enable)||(PathDiv_Trigger)||(pHalData->CurrentBandType == BAND_ON_2_4G))
 828        {
 829            return;
 830        }
 831         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD,("===================>odm_PathDivChkAntSwitch()\n"));
 832
 833        // The first time to switch path excluding 2nd, 3rd, ....etc....
 834         if(switchfirsttime==0)
 835         {
 836             if(regB33==0)
 837             {
 838                pDM_SWAT_Table->CurAntenna = MAIN_ANT;    // Default MAC0_5G-->Path A (current antenna)
 839             }
 840         }
 841
 842         // Condition that does not need to use antenna diversity.
 843         if(pDM_Odm->SupportICType != ODM_RTL8192D)
 844         {
 845                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_PathDiversityMechanims(): No PathDiv Mechanism.\n"));
 846                 return;
 847         }
 848
 849         // Radio off: Status reset to default and return.
 850         if(pHalData->eRFPowerState==eRfOff)
 851         {
 852                 //ODM_SwAntDivRestAfterLink(Adapter);
 853                 return;
 854         }
 855
 856        /*
 857         // Handling step mismatch condition.
 858         // Peak step is not finished at last time. Recover the variable and check again.
 859         if(     Step != pDM_SWAT_Table->try_flag        )
 860         {
 861                 ODM_SwAntDivRestAfterLink(Adapter);
 862         } */
 863
 864         if(pDM_SWAT_Table->try_flag == 0xff)
 865         {
 866                 // Select RSSI checking target
 867                 if(pMgntInfo->mAssoc && !ACTING_AS_AP(Adapter))
 868                 {
 869                         // Target: Infrastructure mode AP.
 870                         pHalData->RSSI_target = NULL;
 871                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_PathDivMechanism(): RSSI_target is DEF AP!\n"));
 872                 }
 873                 else
 874                 {
 875                         u1Byte                  index = 0;
 876                         PRT_WLAN_STA    pEntry = NULL;
 877                         PADAPTER                pTargetAdapter = NULL;
 878
 879                         if(     pMgntInfo->mIbss || ACTING_AS_AP(Adapter) )
 880                         {
 881                                 // Target: AP/IBSS peer.
 882                                 pTargetAdapter = Adapter;
 883                         }
 884                         else if(IsAPModeExist(Adapter)  && GetFirstExtAdapter(Adapter) != NULL)
 885                         {
 886                                 // Target: VWIFI peer.
 887                                 pTargetAdapter = GetFirstExtAdapter(Adapter);
 888                         }
 889
 890                         if(pTargetAdapter != NULL)
 891                         {
 892                                 for(index=0; index<ODM_ASSOCIATE_ENTRY_NUM; index++)
 893                                 {
 894                                         pEntry = AsocEntry_EnumStation(pTargetAdapter, index);
 895                                         if(pEntry != NULL)
 896                                         {
 897                                                 if(pEntry->bAssociated)
 898                                                         break;
 899                                         }
 900                                 }
 901                         }
 902
 903                         if(pEntry == NULL)
 904                         {
 905                                 ODM_PathDivRestAfterLink(pDM_Odm);
 906                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): No Link.\n"));
 907                                 return;
 908                         }
 909                         else
 910                         {
 911                                 pHalData->RSSI_target = pEntry;
 912                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): RSSI_target is PEER STA\n"));
 913                         }
 914                 }
 915
 916                 pHalData->RSSI_cnt_A = 0;
 917                 pHalData->RSSI_cnt_B = 0;
 918                 pDM_SWAT_Table->try_flag = 0;
 919                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("odm_SwAntDivChkAntSwitch(): Set try_flag to 0 prepare for peak!\n"));
 920                 return;
 921         }
 922         else
 923         {
 924                // 1st step
 925                 curTxOkCnt = Adapter->TxStats.NumTxBytesUnicast - lastTxOkCnt;
 926                 curRxOkCnt = Adapter->RxStats.NumRxBytesUnicast - lastRxOkCnt;
 927                 lastTxOkCnt = Adapter->TxStats.NumTxBytesUnicast;
 928                 lastRxOkCnt = Adapter->RxStats.NumRxBytesUnicast;
 929
 930                 if(pDM_SWAT_Table->try_flag == 1)   // Training State
 931                 {
 932                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
 933                         {
 934                                 TXByteCnt_A += curTxOkCnt;
 935                                 RXByteCnt_A += curRxOkCnt;
 936                         }
 937                         else
 938                         {
 939                                 TXByteCnt_B += curTxOkCnt;
 940                                 RXByteCnt_B += curRxOkCnt;
 941                         }
 942
 943                         nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? AUX_ANT : MAIN_ANT;
 944                         pDM_SWAT_Table->RSSI_Trying--;
 945                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_Trying = %d\n",pDM_SWAT_Table->RSSI_Trying));
 946                         if(pDM_SWAT_Table->RSSI_Trying == 0)
 947                         {
 948                                 CurByteCnt = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? (TXByteCnt_A+RXByteCnt_A) : (TXByteCnt_B+RXByteCnt_B);
 949                                 PreByteCnt = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? (TXByteCnt_B+RXByteCnt_B) : (TXByteCnt_A+RXByteCnt_A);
 950
 951                                 if(TrafficLoad == TRAFFIC_HIGH)
 952                                 {
 953                                         //CurByteCnt = PlatformDivision64(CurByteCnt, 9);
 954                                         PreByteCnt =PreByteCnt*9;
 955                                 }
 956                                 else if(TrafficLoad == TRAFFIC_LOW)
 957                                 {
 958                                         //CurByteCnt = PlatformDivision64(CurByteCnt, 2);
 959                                         PreByteCnt =PreByteCnt*2;
 960                                 }
 961                                 if(pHalData->RSSI_cnt_A > 0)
 962                                         RSSI_A = pHalData->RSSI_sum_A/pHalData->RSSI_cnt_A;
 963                                 else
 964                                         RSSI_A = 0;
 965                                 if(pHalData->RSSI_cnt_B > 0)
 966                                         RSSI_B = pHalData->RSSI_sum_B/pHalData->RSSI_cnt_B;
 967                              else
 968                                         RSSI_B = 0;
 969                                 curRSSI = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
 970                                 pDM_SWAT_Table->PreRSSI =  (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_B : RSSI_A;
 971                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: PreRSSI = %d, CurRSSI = %d\n",pDM_SWAT_Table->PreRSSI, curRSSI));
 972                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: preAntenna= %s, curAntenna= %s \n",
 973                                 (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
 974                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_A= %d, RSSI_cnt_A = %d, RSSI_B= %d, RSSI_cnt_B = %d\n",
 975                                         RSSI_A, pHalData->RSSI_cnt_A, RSSI_B, pHalData->RSSI_cnt_B));
 976                         }
 977
 978                 }
 979                 else   // try_flag=0
 980                 {
 981
 982                         if(pHalData->RSSI_cnt_A > 0)
 983                                 RSSI_A = pHalData->RSSI_sum_A/pHalData->RSSI_cnt_A;
 984                         else
 985                                 RSSI_A = 0;
 986                         if(pHalData->RSSI_cnt_B > 0)
 987                                 RSSI_B = pHalData->RSSI_sum_B/pHalData->RSSI_cnt_B;
 988                         else
 989                                 RSSI_B = 0;
 990                         curRSSI = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
 991                         pDM_SWAT_Table->PreRSSI =  (pDM_SWAT_Table->PreAntenna == MAIN_ANT)? RSSI_A : RSSI_B;
 992                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: PreRSSI = %d, CurRSSI = %d\n", pDM_SWAT_Table->PreRSSI, curRSSI));
 993                        ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: preAntenna= %s, curAntenna= %s \n",
 994                         (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
 995
 996                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH DIV=: RSSI_A= %d, RSSI_cnt_A = %d, RSSI_B= %d, RSSI_cnt_B = %d\n",
 997                                 RSSI_A, pHalData->RSSI_cnt_A, RSSI_B, pHalData->RSSI_cnt_B));
 998                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Ekul:curTxOkCnt = %d\n", curTxOkCnt));
 999                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Ekul:curRxOkCnt = %d\n", curRxOkCnt));
1000                 }
1001
1002                 //1 Trying State
1003                 if((pDM_SWAT_Table->try_flag == 1)&&(pDM_SWAT_Table->RSSI_Trying == 0))
1004                 {
1005
1006                         if(pDM_SWAT_Table->TestMode == TP_MODE)
1007                         {
1008                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: TestMode = TP_MODE"));
1009                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH= TRY:CurByteCnt = %"i64fmt"d,", CurByteCnt));
1010                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH= TRY:PreByteCnt = %"i64fmt"d\n",PreByteCnt));
1011                                 if(CurByteCnt < PreByteCnt)
1012                                 {
1013                                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1014                                                 pDM_SWAT_Table->SelectAntennaMap=pDM_SWAT_Table->SelectAntennaMap<<1;
1015                                         else
1016                                                 pDM_SWAT_Table->SelectAntennaMap=(pDM_SWAT_Table->SelectAntennaMap<<1)+1;
1017                                 }
1018                                 else
1019                                 {
1020                                         if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1021                                                 pDM_SWAT_Table->SelectAntennaMap=(pDM_SWAT_Table->SelectAntennaMap<<1)+1;
1022                                         else
1023                                                 pDM_SWAT_Table->SelectAntennaMap=pDM_SWAT_Table->SelectAntennaMap<<1;
1024                                 }
1025                                 for (i= 0; i<8; i++)
1026                                 {
1027                                         if(((pDM_SWAT_Table->SelectAntennaMap>>i)&BIT0) == 1)
1028                                                 Score_A++;
1029                                         else
1030                                                 Score_B++;
1031                                 }
1032                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("SelectAntennaMap=%x\n ",pDM_SWAT_Table->SelectAntennaMap));
1033                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Score_A=%d, Score_B=%d\n", Score_A, Score_B));
1034
1035                                 if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1036                                 {
1037                                         nextAntenna = (Score_A >= Score_B)?MAIN_ANT:AUX_ANT;
1038                                 }
1039                                 else
1040                                 {
1041                                         nextAntenna = (Score_B >= Score_A)?AUX_ANT:MAIN_ANT;
1042                                 }
1043                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: nextAntenna=%s\n",(nextAntenna==MAIN_ANT)?"MAIN":"AUX"));
1044                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: preAntenna= %s, curAntenna= %s \n",
1045                                 (pDM_SWAT_Table->PreAntenna == MAIN_ANT?"MAIN":"AUX"), (pDM_SWAT_Table->CurAntenna == MAIN_ANT?"MAIN":"AUX")));
1046
1047                                 if(nextAntenna != pDM_SWAT_Table->CurAntenna)
1048                                 {
1049                                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Switch back to another antenna"));
1050                                 }
1051                                 else
1052                                 {
1053                                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: current anntena is good\n"));
1054                                 }
1055                         }
1056
1057
1058                         if(pDM_SWAT_Table->TestMode == RSSI_MODE)
1059                         {
1060                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: TestMode = RSSI_MODE"));
1061                                 pDM_SWAT_Table->SelectAntennaMap=0xAA;
1062                                 if(curRSSI < pDM_SWAT_Table->PreRSSI) //Current antenna is worse than previous antenna
1063                                 {
1064                                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: Switch back to another antenna"));
1065                                         nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)?AUX_ANT : MAIN_ANT;
1066                                 }
1067                                 else // current anntena is good
1068                                 {
1069                                         nextAntenna =pDM_SWAT_Table->CurAntenna;
1070                                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: current anntena is good\n"));
1071                                 }
1072                         }
1073
1074                         pDM_SWAT_Table->try_flag = 0;
1075                         pHalData->RSSI_test = FALSE;
1076                         pHalData->RSSI_sum_A = 0;
1077                         pHalData->RSSI_cnt_A = 0;
1078                         pHalData->RSSI_sum_B = 0;
1079                         pHalData->RSSI_cnt_B = 0;
1080                         TXByteCnt_A = 0;
1081                         TXByteCnt_B = 0;
1082                         RXByteCnt_A = 0;
1083                         RXByteCnt_B = 0;
1084
1085                 }
1086
1087                 //1 Normal State
1088                 else if(pDM_SWAT_Table->try_flag == 0)
1089                 {
1090                         if(TrafficLoad == TRAFFIC_HIGH)
1091                         {
1092                                 if ((curTxOkCnt+curRxOkCnt) > 3750000)//if(PlatformDivision64(curTxOkCnt+curRxOkCnt, 2) > 1875000)
1093                                         TrafficLoad = TRAFFIC_HIGH;
1094                                 else
1095                                         TrafficLoad = TRAFFIC_LOW;
1096                         }
1097                         else if(TrafficLoad == TRAFFIC_LOW)
1098                                 {
1099                                 if ((curTxOkCnt+curRxOkCnt) > 3750000)//if(PlatformDivision64(curTxOkCnt+curRxOkCnt, 2) > 1875000)
1100                                         TrafficLoad = TRAFFIC_HIGH;
1101                                 else
1102                                         TrafficLoad = TRAFFIC_LOW;
1103                         }
1104                         if(TrafficLoad == TRAFFIC_HIGH)
1105                                 pDM_SWAT_Table->bTriggerAntennaSwitch = 0;
1106                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("Normal:TrafficLoad = %llu\n", curTxOkCnt+curRxOkCnt));
1107
1108                         //Prepare To Try Antenna
1109                                 nextAntenna = (pDM_SWAT_Table->CurAntenna == MAIN_ANT)? AUX_ANT : MAIN_ANT;
1110                                 pDM_SWAT_Table->try_flag = 1;
1111                                 pHalData->RSSI_test = TRUE;
1112                         if((curRxOkCnt+curTxOkCnt) > 1000)
1113                         {
1114 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1115                             pDM_SWAT_Table->RSSI_Trying = 4;
1116 #else
1117                             pDM_SWAT_Table->RSSI_Trying = 2;
1118 #endif
1119                                 pDM_SWAT_Table->TestMode = TP_MODE;
1120                         }
1121                         else
1122                         {
1123                                 pDM_SWAT_Table->RSSI_Trying = 2;
1124                                 pDM_SWAT_Table->TestMode = RSSI_MODE;
1125
1126                         }
1127
1128                         //RT_TRACE(COMP_INIT, DBG_LOUD, ("SWAS: Normal State -> Begin Trying!\n"));
1129                         pHalData->RSSI_sum_A = 0;
1130                         pHalData->RSSI_cnt_A = 0;
1131                         pHalData->RSSI_sum_B = 0;
1132                         pHalData->RSSI_cnt_B = 0;
1133                 } // end of try_flag=0
1134         }
1135
1136         //1 4.Change TRX antenna
1137         if(nextAntenna != pDM_SWAT_Table->CurAntenna)
1138         {
1139
1140                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Change TX Antenna!\n "));
1141                 //PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, nextAntenna); for 88C
1142                 if(nextAntenna==MAIN_ANT)
1143                 {
1144                     ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Next Antenna is RF PATH A\n "));
1145                     pathdiv_para = 0x02;   //02 to switchback to RF path A
1146                     fw_value = 0x03;
1147 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1148                  odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1149 #else
1150                  ODM_FillH2CCmd(Adapter, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1151 #endif
1152                 }
1153                else if(nextAntenna==AUX_ANT)
1154                {
1155                    ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Next Antenna is RF PATH B\n "));
1156                    if(switchfirsttime==0)  // First Time To Enter Path Diversity
1157                    {
1158                        switchfirsttime=0x01;
1159                       pathdiv_para = 0x00;
1160                           fw_value=0x00;    // to backup RF Path A Releated Registers
1161
1162 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1163                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1164 #else
1165                      ODM_FillH2CCmd(Adapter, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1166                      //for(u1Byte n=0; n<80,n++)
1167                      //{
1168                      //delay_us(500);
1169                           ODM_delay_ms(500);
1170                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1171
1172                          fw_value=0x01;         // to backup RF Path A Releated Registers
1173                      ODM_FillH2CCmd(Adapter, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1174 #endif
1175                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: FIRST TIME To DO PATH SWITCH!\n "));
1176                    }
1177                     else
1178                     {
1179                         pathdiv_para = 0x01;
1180                          fw_value = 0x02;
1181 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1182                      odm_PathDiversity_8192D(pDM_Odm, pathdiv_para);
1183 #else
1184                      ODM_FillH2CCmd(Adapter, ODM_H2C_PathDiv,1,(pu1Byte)(&fw_value));
1185 #endif
1186                     }
1187                }
1188            //   odm_PathDiversity_8192D(Adapter, pathdiv_para);
1189         }
1190
1191         //1 5.Reset Statistics
1192         pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
1193         pDM_SWAT_Table->CurAntenna = nextAntenna;
1194         pDM_SWAT_Table->PreRSSI = curRSSI;
1195
1196         //1 6.Set next timer
1197
1198         if(pDM_SWAT_Table->RSSI_Trying == 0)
1199                 return;
1200
1201         if(pDM_SWAT_Table->RSSI_Trying%2 == 0)
1202         {
1203                 if(pDM_SWAT_Table->TestMode == TP_MODE)
1204                 {
1205                         if(TrafficLoad == TRAFFIC_HIGH)
1206                         {
1207 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1208                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 10 ); //ms
1209                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 10 ms\n"));
1210 #else
1211                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 20 ); //ms
1212                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 20 ms\n"));
1213 #endif
1214                         }
1215                         else if(TrafficLoad == TRAFFIC_LOW)
1216                         {
1217                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 50 ); //ms
1218                                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 50 ms\n"));
1219                         }
1220                 }
1221                 else   // TestMode == RSSI_MODE
1222                 {
1223                         ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 500 ); //ms
1224                         ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 500 ms\n"));
1225                 }
1226         }
1227         else
1228         {
1229                 if(pDM_SWAT_Table->TestMode == TP_MODE)
1230                 {
1231                         if(TrafficLoad == TRAFFIC_HIGH)
1232
1233 #if DEV_BUS_TYPE==RT_PCI_INTERFACE
1234                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 90 ); //ms
1235                                 //ODM_RT_TRACE(pDM_Odm,ODM_COMP_PATH_DIV, ODM_DBG_LOUD, ("=PATH=: Test another antenna for 90 ms\n"));
1236 #else
1237                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 180); //ms
1238 #endif
1239                         else if(TrafficLoad == TRAFFIC_LOW)
1240                                 ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 100 ); //ms
1241                 }
1242                 else
1243                         ODM_SetTimer( pDM_Odm, &pDM_Odm->PathDivSwitchTimer, 500 ); //ms
1244         }
1245 }
1246 \r
1247 \r
1248 \r
1249 VOID
1250 ODM_CCKPathDiversityChkPerPktRssi(
1251         PADAPTER                Adapter,
1252         BOOLEAN                 bIsDefPort,
1253         BOOLEAN                 bMatchBSSID,
1254         PRT_WLAN_STA    pEntry,
1255         PRT_RFD                 pRfd,
1256         pu1Byte                 pDesc
1257         )
1258 {
1259         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1260         BOOLEAN                 bCount = FALSE;
1261         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1262         //BOOLEAN       isCCKrate = RX_HAL_IS_CCK_RATE_92C(pDesc);
1263 #if DEV_BUS_TYPE != RT_SDIO_INTERFACE
1264         BOOLEAN isCCKrate = RX_HAL_IS_CCK_RATE(Adapter, pDesc);
1265 #else  //below code would be removed if we have verified SDIO
1266         BOOLEAN isCCKrate = IS_HARDWARE_TYPE_8188E(Adapter) ? RX_HAL_IS_CCK_RATE_88E(pDesc) : RX_HAL_IS_CCK_RATE_92C(pDesc);
1267 #endif
1268
1269         if((pHalData->PathDivCfg != 1) || (pHalData->RSSI_test == FALSE))
1270                 return;
1271
1272         if(pHalData->RSSI_target==NULL && bIsDefPort && bMatchBSSID)
1273                 bCount = TRUE;
1274         else if(pHalData->RSSI_target!=NULL && pEntry!=NULL && pHalData->RSSI_target==pEntry)
1275                 bCount = TRUE;
1276
1277         if(bCount && isCCKrate)
1278         {
1279                 if(pDM_PDTable->TrainingState == 1 )
1280                 {
1281                         if(pEntry)
1282                         {
1283                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[0] != 0)
1284                                         pEntry->rssi_stat.RSSI_CCK_Path[0] += pRfd->Status.RxPWDBAll;
1285                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[0]++;
1286                         }
1287                         else
1288                         {
1289                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[0] != 0)
1290                                         pDM_PDTable->RSSI_CCK_Path[0] += pRfd->Status.RxPWDBAll;
1291                                 pDM_PDTable->RSSI_CCK_Path_cnt[0]++;
1292                         }
1293                 }
1294                 else if(pDM_PDTable->TrainingState == 2 )
1295                 {
1296                         if(pEntry)
1297                         {
1298                                 if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[1] != 0)
1299                                         pEntry->rssi_stat.RSSI_CCK_Path[1] += pRfd->Status.RxPWDBAll;
1300                                 pEntry->rssi_stat.RSSI_CCK_Path_cnt[1]++;
1301                         }
1302                         else
1303                         {
1304                                 if(pDM_PDTable->RSSI_CCK_Path_cnt[1] != 0)
1305                                         pDM_PDTable->RSSI_CCK_Path[1] += pRfd->Status.RxPWDBAll;
1306                                 pDM_PDTable->RSSI_CCK_Path_cnt[1]++;
1307                         }
1308                 }
1309         }
1310 }
1311
1312
1313
1314
1315 //Neil Chen---2011--06--22
1316 //----92D Path Diversity----//
1317 //#ifdef PathDiv92D
1318 //==================================
1319 //3 Path Diversity
1320 //==================================
1321 //
1322 // 20100514 Luke/Joseph:
1323 // Add new function for antenna diversity after link.
1324 // This is the main function of antenna diversity after link.
1325 // This function is called in HalDmWatchDog() and ODM_SwAntDivChkAntSwitchCallback().
1326 // HalDmWatchDog() calls this function with SWAW_STEP_PEAK to initialize the antenna test.
1327 // In SWAW_STEP_PEAK, another antenna and a 500ms timer will be set for testing.
1328 // After 500ms, ODM_SwAntDivChkAntSwitchCallback() calls this function to compare the signal just
1329 // listened on the air with the RSSI of original antenna.
1330 // It chooses the antenna with better RSSI.
1331 // There is also a aged policy for error trying. Each error trying will cost more 5 seconds waiting
1332 // penalty to get next try.
1333 //
1334 //
1335 // 20100503 Joseph:
1336 // Add new function SwAntDivCheck8192C().
1337 // This is the main function of Antenna diversity function before link.
1338 // Mainly, it just retains last scan result and scan again.
1339 // After that, it compares the scan result to see which one gets better RSSI.
1340 // It selects antenna with better receiving power and returns better scan result.
1341 //
1342
1343
1344 //
1345 // 20100514 Luke/Joseph:
1346 // This function is used to gather the RSSI information for antenna testing.
1347 // It selects the RSSI of the peer STA that we want to know.
1348 //
1349 VOID
1350 ODM_PathDivChkPerPktRssi(
1351         PADAPTER                Adapter,
1352         BOOLEAN                 bIsDefPort,
1353         BOOLEAN                 bMatchBSSID,
1354         PRT_WLAN_STA    pEntry,
1355         PRT_RFD                 pRfd
1356         )
1357 {
1358         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1359         BOOLEAN                 bCount = FALSE;
1360         PDM_ODM_T               pDM_Odm = &pHalData->DM_OutSrc;
1361         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
1362
1363         if(pHalData->RSSI_target==NULL && bIsDefPort && bMatchBSSID)
1364                 bCount = TRUE;
1365         else if(pHalData->RSSI_target!=NULL && pEntry!=NULL && pHalData->RSSI_target==pEntry)
1366                 bCount = TRUE;
1367
1368         if(bCount)
1369         {
1370                 //1 RSSI for SW Antenna Switch
1371                 if(pDM_SWAT_Table->CurAntenna == MAIN_ANT)
1372                 {
1373                         pHalData->RSSI_sum_A += pRfd->Status.RxPWDBAll;
1374                         pHalData->RSSI_cnt_A++;
1375                 }
1376                 else
1377                 {
1378                         pHalData->RSSI_sum_B += pRfd->Status.RxPWDBAll;
1379                         pHalData->RSSI_cnt_B++;
1380
1381                 }
1382         }
1383 }
1384 \r
1385 \r
1386 //
1387 // 20100514 Luke/Joseph:
1388 // Add new function to reset antenna diversity state after link.
1389 //
1390 VOID
1391 ODM_PathDivRestAfterLink(
1392         IN      PDM_ODM_T               pDM_Odm
1393         )
1394 {
1395         PADAPTER                Adapter=pDM_Odm->Adapter;
1396         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1397         pSWAT_T                 pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
1398
1399         pHalData->RSSI_cnt_A = 0;
1400         pHalData->RSSI_cnt_B = 0;
1401         pHalData->RSSI_test = FALSE;
1402         pDM_SWAT_Table->try_flag = 0x0;       // NOT 0xff
1403         pDM_SWAT_Table->RSSI_Trying = 0;
1404         pDM_SWAT_Table->SelectAntennaMap=0xAA;
1405         pDM_SWAT_Table->CurAntenna = MAIN_ANT;
1406 }\r
1407 \r
1408 \r
1409 //==================================================
1410 //3 PathDiv End
1411 //==================================================\r
1412 \r
1413 \r
1414 VOID
1415 ODM_FillTXPathInTXDESC(
1416                 IN      PADAPTER        Adapter,
1417                 IN      PRT_TCB         pTcb,
1418                 IN      pu1Byte         pDesc
1419 )
1420 {
1421         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(Adapter);
1422         u4Byte  TXPath;
1423         pPD_T   pDM_PDTable = &Adapter->DM_PDTable;
1424
1425         //2011.09.05  Add by Luke Lee for path diversity
1426         if(pHalData->PathDivCfg == 1)
1427         {
1428                 TXPath = (pDM_PDTable->OFDMTXPath >> pTcb->macId) & BIT0;
1429                 //RT_TRACE(     COMP_INIT, DBG_LOUD, ("Fill TXDESC: macID=%d, TXPath=%d\n", pTcb->macId, TXPath));
1430                 //SET_TX_DESC_TX_ANT_CCK(pDesc,TXPath);
1431                 if(TXPath == 0)
1432                 {
1433                         SET_TX_DESC_TX_ANTL_92C(pDesc,1);
1434                         SET_TX_DESC_TX_ANT_HT_92C(pDesc,1);
1435                 }
1436                 else
1437                 {
1438                         SET_TX_DESC_TX_ANTL_92C(pDesc,2);
1439                         SET_TX_DESC_TX_ANT_HT_92C(pDesc,2);
1440                 }
1441                 TXPath = (pDM_PDTable->CCKTXPath >> pTcb->macId) & BIT0;
1442                 if(TXPath == 0)
1443                 {
1444                         SET_TX_DESC_TX_ANT_CCK_92C(pDesc,1);
1445                 }
1446                 else
1447                 {
1448                         SET_TX_DESC_TX_ANT_CCK_92C(pDesc,2);
1449                 }
1450         }
1451 }
1452
1453 //Only for MP //Neil Chen--2012--0502--
1454 VOID
1455 odm_PathDivInit_92D(
1456 IN      PDM_ODM_T       pDM_Odm)
1457 {
1458         pPATHDIV_PARA   pathIQK = &pDM_Odm->pathIQK;
1459
1460         pathIQK->org_2g_RegC14=0x0;
1461         pathIQK->org_2g_RegC4C=0x0;
1462         pathIQK->org_2g_RegC80=0x0;
1463         pathIQK->org_2g_RegC94=0x0;
1464         pathIQK->org_2g_RegCA0=0x0;
1465         pathIQK->org_5g_RegC14=0x0;
1466         pathIQK->org_5g_RegCA0=0x0;
1467         pathIQK->org_5g_RegE30=0x0;
1468         pathIQK->swt_2g_RegC14=0x0;
1469         pathIQK->swt_2g_RegC4C=0x0;
1470         pathIQK->swt_2g_RegC80=0x0;
1471         pathIQK->swt_2g_RegC94=0x0;
1472         pathIQK->swt_2g_RegCA0=0x0;
1473         pathIQK->swt_5g_RegC14=0x0;
1474         pathIQK->swt_5g_RegCA0=0x0;
1475         pathIQK->swt_5g_RegE30=0x0;
1476
1477 }\r
1478 \r
1479 \r
1480 u1Byte
1481 odm_SwAntDivSelectScanChnl(
1482         IN      PADAPTER        Adapter
1483         )
1484 {
1485 #if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
1486         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(Adapter);
1487         PMGNT_INFO                      pMgntInfo = &(Adapter->MgntInfo);
1488         PDM_ODM_T                       pDM_Odm = &pHalData->DM_OutSrc;
1489         u1Byte                          i, j, ScanChannel = 0, ChannelNum = 0;
1490         PRT_CHANNEL_LIST        pChannelList = GET_RT_CHANNEL_LIST(pMgntInfo);
1491         u1Byte                          EachChannelSTAs[MAX_SCAN_CHANNEL_NUM] = {0};
1492
1493         if(pMgntInfo->tmpNumBssDesc == 0)
1494                 return 0;
1495
1496         for(i = 0; i < pMgntInfo->tmpNumBssDesc; i++)
1497         {
1498                 ChannelNum = pMgntInfo->tmpbssDesc[i].ChannelNumber;
1499                 for(j = 0; j < pChannelList->ChannelLen; j++)
1500                 {
1501                         if(pChannelList->ChnlListEntry[j].ChannelNum == ChannelNum)
1502                         {
1503                                 EachChannelSTAs[j]++;
1504                                 break;
1505                         }
1506                 }
1507         }
1508
1509         for(i = 0; i < MAX_SCAN_CHANNEL_NUM; i++)
1510                 {
1511                 if(EachChannelSTAs[i] > EachChannelSTAs[ScanChannel])
1512                         ScanChannel = i;
1513                 }
1514
1515         if(EachChannelSTAs[ScanChannel] == 0)
1516         {
1517                 ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("odm_SwAntDivSelectScanChnl(): Scan List is empty.\n"));
1518                 return 0;
1519         }
1520
1521         ScanChannel = pChannelList->ChnlListEntry[ScanChannel].ChannelNum;
1522
1523
1524
1525         ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD,
1526                 ("odm_SwAntDivSelectScanChnl(): Channel (( %d )) is select as scan channel.\n", ScanChannel));
1527
1528         return ScanChannel;
1529 #else
1530         return  0;
1531 #endif
1532 }
1533
1534
1535 VOID
1536 odm_SwAntDivConstructScanChnl(
1537         IN      PADAPTER        Adapter,
1538         IN      u1Byte          ScanChnl
1539         )
1540 {
1541
1542         PMGNT_INFO                      pMgntInfo = &Adapter->MgntInfo;
1543
1544         if(ScanChnl == 0)
1545         {
1546                 u1Byte                          i;
1547                 PRT_CHANNEL_LIST        pChannelList = GET_RT_CHANNEL_LIST(pMgntInfo);
1548
1549                 // 20100519 Joseph: Original antenna scanned nothing.
1550                 // Test antenna shall scan all channel with half period in this condition.
1551
1552                 RT_TRACE_F(COMP_SCAN, DBG_TRACE, (" RT_CHNL_LIST_ACTION_CONSTRUCT chnl %d \n", ScanChnl));
1553
1554                 RtActChannelList(Adapter, RT_CHNL_LIST_ACTION_CONSTRUCT_SCAN_LIST, NULL, NULL);
1555                 for(i = 0; i < pChannelList->ChannelLen; i++)
1556                         pChannelList->ChnlListEntry[i].ScanPeriod /= 2;
1557         }
1558         else
1559         {
1560                 // The using of this CustomizedScanRequest is a trick to rescan the two channels
1561                 //      under the NORMAL scanning process. It will not affect MGNT_INFO.CustomizedScanRequest.
1562                 CUSTOMIZED_SCAN_REQUEST CustomScanReq;
1563
1564                 CustomScanReq.bEnabled = TRUE;
1565                 CustomScanReq.Channels[0] = ScanChnl;
1566                 CustomScanReq.Channels[1] = pMgntInfo->dot11CurrentChannelNumber;
1567                 CustomScanReq.nChannels = 2;
1568                 CustomScanReq.ScanType = SCAN_ACTIVE;
1569                 CustomScanReq.Duration = DEFAULT_PASSIVE_SCAN_PERIOD;
1570
1571                 RT_TRACE_F(COMP_SCAN, DBG_TRACE, (" RT_CHNL_LIST_ACTION_CONSTRUCT chnl %d \n", ScanChnl));
1572
1573                 RtActChannelList(Adapter, RT_CHNL_LIST_ACTION_CONSTRUCT_SCAN_LIST, &CustomScanReq, NULL);
1574         }
1575
1576 }
1577 \r
1578 \r
1579 #endif  // #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
1580 \r