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