VOID
RxPktPendingTimeout(
PRT_TIMER pTimer
)
{
PADAPTER Adapter = (PADAPTER)pTimer->Adapter;
PRX_TS_RECORD pRxTS = (PRX_TS_RECORD)pTimer->Context;
BOOLEAN bSupportAvoidRxDpcWatchdogVoilation = FALSE;
RT_TRACE(COMP_RX_REORDER, DBG_WARNING, ("==>RxPktPendingTimeout()\n"));
//Only 8814AE set bSupportAvoidRxDpcWatchdogVoilation ture now.
Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_AVOID_RX_DPC_WATCHDOG_VIOLATION, (pu1Byte)(&bSupportAvoidRxDpcWatchdogVoilation));
if(bSupportAvoidRxDpcWatchdogVoilation)
{
if(Adapter->IntrInterruptRefCount == TRUE)
{
PlatformSetTimer(Adapter, &pRxTS->RxPktPendingTimer, 1);
return;
}
if(PlatformAtomicExchange(&Adapter->RxPktPendingTimeoutRefCount, TRUE) == TRUE)
{
PlatformSetTimer(Adapter, &pRxTS->RxPktPendingTimer, 1);
return;
}
}
PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
// Only do indication process in Batch and Reorder state in this function.
if(pRxTS->RxIndicateState==RXTS_INDICATE_BATCH)
IndicateRxReorderList(Adapter, pRxTS, FALSE);
else if(pRxTS->RxIndicateState==RXTS_INDICATE_REORDER)
IndicateRxReorderList(Adapter, pRxTS, TRUE);
PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
if(bSupportAvoidRxDpcWatchdogVoilation)
PlatformAtomicExchange(&Adapter->RxPktPendingTimeoutRefCount, FALSE);
RT_TRACE(COMP_RX_REORDER, DBG_WARNING, ("<==RxPktPendingTimeout()\n"));
}
VOID
ODM_SetTimer(
IN PDM_ODM_T pDM_Odm,
IN PRT_TIMER pTimer,
IN u4Byte msDelay
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
mod_timer(pTimer, jiffies + (msDelay+9)/10);
#elif(DM_ODM_SUPPORT_TYPE & ODM_CE)
_set_timer(pTimer,msDelay ); //ms
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
PADAPTER Adapter = pDM_Odm->Adapter;
PlatformSetTimer(Adapter, pTimer, msDelay);
#endif
}
VOID
ODM_SetTimer(
IN PDM_ODM_T pDM_Odm,
IN PRT_TIMER pTimer,
IN u4Byte msDelay
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
mod_timer(pTimer, jiffies + RTL_MILISECONDS_TO_JIFFIES(msDelay));
#elif(DM_ODM_SUPPORT_TYPE & ODM_CE)
_set_timer(pTimer,msDelay ); //ms
#elif(DM_ODM_SUPPORT_TYPE & ODM_WIN)
PADAPTER Adapter = pDM_Odm->Adapter;
PlatformSetTimer(Adapter, pTimer, msDelay);
#endif
}
void
ODM_SetTimer(
PDM_ODM_T pDM_Odm,
PRT_TIMER pTimer,
u32 msDelay
)
{
#if(DM_ODM_SUPPORT_TYPE & (ODM_AP|ODM_ADSL))
mod_timer(pTimer, jiffies + (msDelay+9)/10);
#elif(DM_ODM_SUPPORT_TYPE & ODM_CE)
_set_timer(pTimer,msDelay ); //ms
#elif(DM_ODM_SUPPORT_TYPE & ODM_MP)
struct rtw_adapter * Adapter = pDM_Odm->Adapter;
PlatformSetTimer(Adapter, pTimer, msDelay);
#endif
}
BOOLEAN
ODM_PathDiversityBeforeLink92C(
//IN PADAPTER Adapter
IN PDM_ODM_T pDM_Odm
)
{
#if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
PADAPTER Adapter = pDM_Odm->Adapter;
HAL_DATA_TYPE* pHalData = NULL;
PMGNT_INFO pMgntInfo = NULL;
//pSWAT_T pDM_SWAT_Table = &Adapter->DM_SWAT_Table;
pPD_T pDM_PDTable = NULL;
s1Byte Score = 0;
PRT_WLAN_BSS pTmpBssDesc;
PRT_WLAN_BSS pTestBssDesc;
u1Byte target_chnl = 0;
u2Byte index;
if (pDM_Odm->Adapter == NULL) //For BSOD when plug/unplug fast. //By YJ,120413
{ // The ODM structure is not initialized.
return FALSE;
}
pHalData = GET_HAL_DATA(Adapter);
pMgntInfo = &Adapter->MgntInfo;
pDM_PDTable = &Adapter->DM_PDTable;
// Condition that does not need to use path diversity.
if((!(pHalData->CVID_Version==VERSION_1_BEFORE_8703B && IS_92C_SERIAL(pHalData->VersionID))) || (pHalData->PathDivCfg!=1) || pMgntInfo->AntennaTest )
{
RT_TRACE(COMP_INIT, DBG_LOUD,
("ODM_PathDiversityBeforeLink92C(): No PathDiv Mechanism before link.\n"));
return FALSE;
}
// Since driver is going to set BB register, it shall check if there is another thread controlling BB/RF.
PlatformAcquireSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
if(pHalData->eRFPowerState!=eRfOn || pMgntInfo->RFChangeInProgress || pMgntInfo->bMediaConnect)
{
PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
RT_TRACE(COMP_INIT, DBG_LOUD,
("ODM_PathDiversityBeforeLink92C(): RFChangeInProgress(%x), eRFPowerState(%x)\n",
pMgntInfo->RFChangeInProgress,
pHalData->eRFPowerState));
//pDM_SWAT_Table->SWAS_NoLink_State = 0;
pDM_PDTable->PathDiv_NoLink_State = 0;
return FALSE;
}
else
{
PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
}
//1 Run AntDiv mechanism "Before Link" part.
//if(pDM_SWAT_Table->SWAS_NoLink_State == 0)
if(pDM_PDTable->PathDiv_NoLink_State == 0)
{
//1 Prepare to do Scan again to check current antenna state.
// Set check state to next step.
//pDM_SWAT_Table->SWAS_NoLink_State = 1;
pDM_PDTable->PathDiv_NoLink_State = 1;
// Copy Current Scan list.
Adapter->MgntInfo.tmpNumBssDesc = pMgntInfo->NumBssDesc;
PlatformMoveMemory((PVOID)Adapter->MgntInfo.tmpbssDesc, (PVOID)pMgntInfo->bssDesc, sizeof(RT_WLAN_BSS)*MAX_BSS_DESC);
// Switch Antenna to another one.
if(pDM_PDTable->DefaultRespPath == 0)
{
PHY_SetBBReg(Adapter, rCCK0_AFESetting , 0x0F000000, 0x05); // TRX path = PathB
odm_SetRespPath_92C(Adapter, 1);
pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
}
else
{
PHY_SetBBReg(Adapter, rCCK0_AFESetting , 0x0F000000, 0x00); // TRX path = PathA
odm_SetRespPath_92C(Adapter, 0);
pDM_PDTable->OFDMTXPath = 0x0;
pDM_PDTable->CCKTXPath = 0x0;
}
#if 0
pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
pDM_SWAT_Table->CurAntenna = (pDM_SWAT_Table->CurAntenna==Antenna_A)?Antenna_B:Antenna_A;
RT_TRACE(COMP_INIT, DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink: Change to Ant(%s) for testing.\n", (pDM_SWAT_Table->CurAntenna==Antenna_A)?"A":"B"));
//PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
#endif
// Go back to scan function again.
RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Scan one more time\n"));
pMgntInfo->ScanStep=0;
target_chnl = odm_SwAntDivSelectScanChnl(Adapter);
odm_SwAntDivConstructScanChnl(Adapter, target_chnl);
PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
return TRUE;
}
else
{
//1 ScanComple() is called after antenna swiched.
//1 Check scan result and determine which antenna is going
//1 to be used.
for(index=0; index<Adapter->MgntInfo.tmpNumBssDesc; index++)
{
pTmpBssDesc = &(Adapter->MgntInfo.tmpbssDesc[index]);
pTestBssDesc = &(pMgntInfo->bssDesc[index]);
if(PlatformCompareMemory(pTestBssDesc->bdBssIdBuf, pTmpBssDesc->bdBssIdBuf, 6)!=0)
{
RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C(): ERROR!! This shall not happen.\n"));
continue;
}
if(pTmpBssDesc->RecvSignalPower > pTestBssDesc->RecvSignalPower)
{
RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score++\n"));
RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
Score++;
PlatformMoveMemory(pTestBssDesc, pTmpBssDesc, sizeof(RT_WLAN_BSS));
}
else if(pTmpBssDesc->RecvSignalPower < pTestBssDesc->RecvSignalPower)
{
RT_TRACE(COMP_INIT, DBG_LOUD, ("ODM_PathDiversityBeforeLink92C: Compare scan entry: Score--\n"));
RT_PRINT_STR(COMP_INIT, DBG_LOUD, "SSID: ", pTestBssDesc->bdSsIdBuf, pTestBssDesc->bdSsIdLen);
RT_TRACE(COMP_INIT, DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
Score--;
}
}
if(pMgntInfo->NumBssDesc!=0 && Score<=0)
{
RT_TRACE(COMP_INIT, DBG_LOUD,
("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
//pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
}
else
{
RT_TRACE(COMP_INIT, DBG_LOUD,
("ODM_PathDiversityBeforeLink92C(): DefaultRespPath=%d\n", pDM_PDTable->DefaultRespPath));
if(pDM_PDTable->DefaultRespPath == 0)
{
pDM_PDTable->OFDMTXPath = 0xFFFFFFFF;
pDM_PDTable->CCKTXPath = 0xFFFFFFFF;
odm_SetRespPath_92C(Adapter, 1);
}
else
{
pDM_PDTable->OFDMTXPath = 0x0;
pDM_PDTable->CCKTXPath = 0x0;
odm_SetRespPath_92C(Adapter, 0);
}
PHY_SetBBReg(Adapter, rCCK0_AFESetting , 0x0F000000, 0x01); // RX path = PathAB
//pDM_SWAT_Table->CurAntenna = pDM_SWAT_Table->PreAntenna;
//PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, 0x300, DM_SWAT_Table.CurAntenna);
//pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
//PHY_SetBBReg(Adapter, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
}
// Check state reset to default and wait for next time.
//pDM_SWAT_Table->SWAS_NoLink_State = 0;
pDM_PDTable->PathDiv_NoLink_State = 0;
return FALSE;
}
#else
return FALSE;
#endif
}
void
KeyMgntTimeout(
PRT_TIMER pTimer
)
{
PADAPTER Adapter=(PADAPTER)pTimer->Adapter;
PMGNT_INFO pMgntInfo = &Adapter->MgntInfo;
PAUTH_PKEY_MGNT_TAG pKeyMgnt;
int i;
int AsocNum = 0;
PRT_WLAN_STA pEntry;
if( !ACTING_AS_AP(Adapter) )
{
RT_TRACE( COMP_AUTHENTICATOR, DBG_LOUD, ("[Warning!!] KeyMgntTimeout(): STA mode\n"));
return;
}
else
{
//RT_TRACE( COMP_AUTHENTICATOR, DBG_LOUD, ("KeyMgntTimeout(): AP mode, CurrentTimeSlot=%d\n", pMgntInfo->globalKeyInfo.CurrentTimeSlot ));
}
if( pMgntInfo->SecurityInfo.AuthMode == RT_802_11AuthModeWPAPSK ||
pMgntInfo->SecurityInfo.AuthMode == RT_802_11AuthModeWPA2PSK ||
pMgntInfo->SecurityInfo.SecLvl == RT_SEC_LVL_WPA2)
{
// Query all stations' state and their timeout count.
for( i=0; i<ASSOCIATE_ENTRY_NUM; i++ )
{
if( !pMgntInfo->AsocEntry[i].bUsed )
continue;
pKeyMgnt = &pMgntInfo->AsocEntry[i].perSTAKeyInfo;
// Print Dbg Message. 2005-07-25, Annie.------------
AsocNum++;
pEntry = pKeyMgnt->pWLanSTA;
RT_TRACE( COMP_AUTHENTICATOR, DBG_LOUD, ("[STA:%d] %02X-%02X-%02X-%02X-%02X-%02X, MicErrorCnt=%d, WEPErrorCnt=%d\n",
i, pEntry->MacAddr[0], pEntry->MacAddr[1], pEntry->MacAddr[2], pEntry->MacAddr[3], pEntry->MacAddr[4], pEntry->MacAddr[5],
pKeyMgnt->MicErrorCnt, pKeyMgnt->WEPErrorCnt ) );
//---------------------------------------------
if( KeyMgntStateIsWaitingEAPOLKey(pKeyMgnt) && pKeyMgnt->GrState != ASMGS_REKEYESTABLISHED )
{
if( pKeyMgnt->TimeoutCtr >= MAX_TIMEOUT_CNT )
{
pKeyMgnt->TimeoutCtr = 0;
Authenticator_OnTimeoutCountExceeded(Adapter, pKeyMgnt);
}
else
{
if( pMgntInfo->globalKeyInfo.CurrentTimeSlot != pKeyMgnt->TimeSlot_lastsend ) // consider 1st retry should wait for at least 1 second. Annie, 2005-07-12.
{
//RT_TRACE(COMP_AUTHENTICATOR, DBG_LOUD, ("KeyMgntTimeout(): Retry! [TimeSlot:%"i64fmt"d, TimeoutCtr:%d]\n",
// pMgntInfo->globalKeyInfo.CurrentTimeSlot, (int)pKeyMgnt->TimeoutCtr ));
pKeyMgnt->TimeoutCtr ++;
if( pKeyMgnt->PrState == ASMPS_PTKSTART ) // waiting for 2nd msg in 4-way handshake
{
Authenticator_StatePTKSTART(Adapter, &pMgntInfo->AsocEntry[i]);
}
else if( pKeyMgnt->PrState == ASMPS_PTKINITNEGOTIATING ) // waiting for 4th msg in 4-way handshake
{
Authenticator_StatePTKINITNEGOTIATING(Adapter, &pMgntInfo->AsocEntry[i]);
}
else if( pKeyMgnt->GrState == ASMGS_REKEYNEGOTIATING ) // waiting for 2nd msg in 2-way handshake
{
Authenticator_StateREKEYNEGOTIATING(Adapter, &pMgntInfo->AsocEntry[i]);
}
}
else
{
RT_TRACE( COMP_AUTHENTICATOR, DBG_LOUD, ("KeyMgntTimeout(): equal TimeSlot. Not to retry.\n") );
}
}
}
}
//RT_TRACE( COMP_AUTHENTICATOR, DBG_LOUD, ("KeyMgntTimeout: AsocNum=%d, CurrentTimeSlot=%"i64fmt"d\n", AsocNum, pMgntInfo->globalKeyInfo.CurrentTimeSlot ) );
// Continue setting the timer only when RT_802_11AuthModeWPAPSK.
pMgntInfo->globalKeyInfo.CurrentTimeSlot ++;
PlatformSetTimer( Adapter, &pMgntInfo->globalKeyInfo.KeyMgntTimer, KEY_MGNT_INTERVAL );
}
}
BOOLEAN
ODM_SwAntDivCheckBeforeLink(
IN PVOID pDM_VOID
)
{
#if (RT_MEM_SIZE_LEVEL != RT_MEM_SIZE_MINIMUM)
PDM_ODM_T pDM_Odm = (PDM_ODM_T)pDM_VOID;
PADAPTER Adapter = pDM_Odm->Adapter;
HAL_DATA_TYPE* pHalData = GET_HAL_DATA(Adapter);
PMGNT_INFO pMgntInfo = &Adapter->MgntInfo;
pSWAT_T pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
pFAT_T pDM_FatTable = &pDM_Odm->DM_FatTable;
s1Byte Score = 0;
PRT_WLAN_BSS pTmpBssDesc, pTestBssDesc;
u1Byte power_target = 10, power_target_L = 9, power_target_H = 16;
u1Byte tmp_power_diff = 0,power_diff = 0,avg_power_diff = 0,max_power_diff = 0,min_power_diff = 0xff;
u2Byte index, counter = 0;
static u1Byte ScanChannel;
u8Byte tStamp_diff = 0;
u4Byte tmp_SWAS_NoLink_BK_Reg948;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ANTA_ON = (( %d )) , ANTB_ON = (( %d )) \n",pDM_Odm->DM_SWAT_Table.ANTA_ON ,pDM_Odm->DM_SWAT_Table.ANTB_ON ));
//if(HP id)
{
if(pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult==TRUE && pDM_Odm->SupportICType == ODM_RTL8723B)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("8723B RSSI-based Antenna Detection is done\n"));
return FALSE;
}
if(pDM_Odm->SupportICType == ODM_RTL8723B)
{
if(pDM_SWAT_Table->SWAS_NoLink_BK_Reg948 == 0xff)
pDM_SWAT_Table->SWAS_NoLink_BK_Reg948 = ODM_Read4Byte(pDM_Odm, rS0S1_PathSwitch );
}
}
if (pDM_Odm->Adapter == NULL) //For BSOD when plug/unplug fast. //By YJ,120413
{ // The ODM structure is not initialized.
return FALSE;
}
// Retrieve antenna detection registry info, added by Roger, 2012.11.27.
if(!IS_ANT_DETECT_SUPPORT_RSSI(Adapter))
{
return FALSE;
}
else
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Antenna Detection: RSSI Method\n"));
}
// Since driver is going to set BB register, it shall check if there is another thread controlling BB/RF.
PlatformAcquireSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
if(pHalData->eRFPowerState!=eRfOn || pMgntInfo->RFChangeInProgress || pMgntInfo->bMediaConnect)
{
PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink(): RFChangeInProgress(%x), eRFPowerState(%x)\n",
pMgntInfo->RFChangeInProgress, pHalData->eRFPowerState));
pDM_SWAT_Table->SWAS_NoLink_State = 0;
return FALSE;
}
else
{
PlatformReleaseSpinLock(Adapter, RT_RF_STATE_SPINLOCK);
}
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("pDM_SWAT_Table->SWAS_NoLink_State = %d\n", pDM_SWAT_Table->SWAS_NoLink_State));
//1 Run AntDiv mechanism "Before Link" part.
if(pDM_SWAT_Table->SWAS_NoLink_State == 0)
{
//1 Prepare to do Scan again to check current antenna state.
// Set check state to next step.
pDM_SWAT_Table->SWAS_NoLink_State = 1;
// Copy Current Scan list.
pMgntInfo->tmpNumBssDesc = pMgntInfo->NumBssDesc;
PlatformMoveMemory((PVOID)Adapter->MgntInfo.tmpbssDesc, (PVOID)pMgntInfo->bssDesc, sizeof(RT_WLAN_BSS)*MAX_BSS_DESC);
// Go back to scan function again.
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink: Scan one more time\n"));
pMgntInfo->ScanStep=0;
pMgntInfo->bScanAntDetect = TRUE;
ScanChannel = odm_SwAntDivSelectScanChnl(Adapter);
if(pDM_Odm->SupportICType & (ODM_RTL8188E|ODM_RTL8821))
{
if(pDM_FatTable->RxIdleAnt == MAIN_ANT)
ODM_UpdateRxIdleAnt(pDM_Odm, AUX_ANT);
else
ODM_UpdateRxIdleAnt(pDM_Odm, MAIN_ANT);
if(ScanChannel == 0)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink(): No AP List Avaiable, Using Ant(%s)\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"AUX_ANT":"MAIN_ANT"));
if(IS_5G_WIRELESS_MODE(pMgntInfo->dot11CurrentWirelessMode))
{
pDM_SWAT_Table->Ant5G = pDM_FatTable->RxIdleAnt;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("pDM_SWAT_Table->Ant5G=%s\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"MAIN_ANT":"AUX_ANT"));
}
else
{
pDM_SWAT_Table->Ant2G = pDM_FatTable->RxIdleAnt;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("pDM_SWAT_Table->Ant2G=%s\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"MAIN_ANT":"AUX_ANT"));
}
return FALSE;
}
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink: Change to %s for testing.\n", ((pDM_FatTable->RxIdleAnt == MAIN_ANT)?"MAIN_ANT":"AUX_ANT")));
}
else if(pDM_Odm->SupportICType & (ODM_RTL8192C|ODM_RTL8723B))
{
if(pDM_Odm->SupportICType == ODM_RTL8192C)
{
// Switch Antenna to another one.
pDM_SWAT_Table->PreAntenna = pDM_SWAT_Table->CurAntenna;
pDM_SWAT_Table->CurAntenna = (pDM_SWAT_Table->CurAntenna==MAIN_ANT)?AUX_ANT:MAIN_ANT;
pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 = ((pDM_SWAT_Table->SWAS_NoLink_BK_Reg860 & 0xfffffcff) | (pDM_SWAT_Table->CurAntenna<<8));
ODM_SetBBReg(pDM_Odm, rFPGA0_XA_RFInterfaceOE, bMaskDWord, pDM_SWAT_Table->SWAS_NoLink_BK_Reg860);
}
else if(pDM_Odm->SupportICType == ODM_RTL8723B)
{
// Switch Antenna to another one.
tmp_SWAS_NoLink_BK_Reg948 = ODM_Read4Byte(pDM_Odm, rS0S1_PathSwitch );
if( (pDM_SWAT_Table->CurAntenna = MAIN_ANT) && (tmp_SWAS_NoLink_BK_Reg948==0x200))
{
ODM_SetBBReg(pDM_Odm, rS0S1_PathSwitch, 0xfff, 0x280);
ODM_SetBBReg(pDM_Odm, rAGC_table_select, BIT31, 0x1);
pDM_SWAT_Table->CurAntenna = AUX_ANT;
}
else
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("Reg[948]= (( %x )) was in wrong state\n", tmp_SWAS_NoLink_BK_Reg948 ));
return FALSE;
}
ODM_StallExecution(10);
}
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink: Change to (( %s-ant)) for testing.\n", (pDM_SWAT_Table->CurAntenna==MAIN_ANT)?"MAIN":"AUX"));
}
odm_SwAntDivConstructScanChnl(Adapter, ScanChannel);
PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
return TRUE;
}
else //pDM_SWAT_Table->SWAS_NoLink_State == 1
{
//1 ScanComple() is called after antenna swiched.
//1 Check scan result and determine which antenna is going
//1 to be used.
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,(" tmpNumBssDesc= (( %d )) \n",pMgntInfo->tmpNumBssDesc));// debug for Dino
for(index = 0; index < pMgntInfo->tmpNumBssDesc; index++)
{
pTmpBssDesc = &(pMgntInfo->tmpbssDesc[index]); // Antenna 1
pTestBssDesc = &(pMgntInfo->bssDesc[index]); // Antenna 2
if(PlatformCompareMemory(pTestBssDesc->bdBssIdBuf, pTmpBssDesc->bdBssIdBuf, 6)!=0)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink(): ERROR!! This shall not happen.\n"));
continue;
}
if(pDM_Odm->SupportICType != ODM_RTL8723B)
{
if(pTmpBssDesc->ChannelNumber == ScanChannel)
{
if(pTmpBssDesc->RecvSignalPower > pTestBssDesc->RecvSignalPower)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink: Compare scan entry: Score++\n"));
RT_PRINT_STR(COMP_SCAN, DBG_WARNING, "GetScanInfo(): new Bss SSID:", pTmpBssDesc->bdSsIdBuf, pTmpBssDesc->bdSsIdLen);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("at ch %d, Original: %d, Test: %d\n\n", pTmpBssDesc->ChannelNumber, pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
Score++;
PlatformMoveMemory(pTestBssDesc, pTmpBssDesc, sizeof(RT_WLAN_BSS));
}
else if(pTmpBssDesc->RecvSignalPower < pTestBssDesc->RecvSignalPower)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink: Compare scan entry: Score--\n"));
RT_PRINT_STR(COMP_SCAN, DBG_WARNING, "GetScanInfo(): new Bss SSID:", pTmpBssDesc->bdSsIdBuf, pTmpBssDesc->bdSsIdLen);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("at ch %d, Original: %d, Test: %d\n\n", pTmpBssDesc->ChannelNumber, pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
Score--;
}
else
{
if(pTestBssDesc->bdTstamp - pTmpBssDesc->bdTstamp < 5000)
{
RT_PRINT_STR(COMP_SCAN, DBG_WARNING, "GetScanInfo(): new Bss SSID:", pTmpBssDesc->bdSsIdBuf, pTmpBssDesc->bdSsIdLen);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("at ch %d, Original: %d, Test: %d\n", pTmpBssDesc->ChannelNumber, pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("The 2nd Antenna didn't get this AP\n\n"));
}
}
}
}
else // 8723B
{
if(pTmpBssDesc->ChannelNumber == ScanChannel)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("ChannelNumber == ScanChannel -> (( %d )) \n", pTmpBssDesc->ChannelNumber ));
if(pTmpBssDesc->RecvSignalPower > pTestBssDesc->RecvSignalPower) // Pow(Ant1) > Pow(Ant2)
{
counter++;
tmp_power_diff=(u1Byte)(pTmpBssDesc->RecvSignalPower - pTestBssDesc->RecvSignalPower);
power_diff = power_diff + tmp_power_diff;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("SSID:"), pTmpBssDesc->bdSsIdBuf);
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("BSSID:"), pTmpBssDesc->bdBssIdBuf);
//ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("tmp_power_diff: (( %d)),max_power_diff: (( %d)),min_power_diff: (( %d)) \n", tmp_power_diff,max_power_diff,min_power_diff));
if(tmp_power_diff > max_power_diff)
max_power_diff=tmp_power_diff;
if(tmp_power_diff < min_power_diff)
min_power_diff=tmp_power_diff;
//ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("max_power_diff: (( %d)),min_power_diff: (( %d)) \n",max_power_diff,min_power_diff));
PlatformMoveMemory(pTestBssDesc, pTmpBssDesc, sizeof(RT_WLAN_BSS));
}
else if(pTestBssDesc->RecvSignalPower > pTmpBssDesc->RecvSignalPower) // Pow(Ant1) < Pow(Ant2)
{
counter++;
tmp_power_diff=(u1Byte)(pTestBssDesc->RecvSignalPower - pTmpBssDesc->RecvSignalPower);
power_diff = power_diff + tmp_power_diff;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("SSID:"), pTmpBssDesc->bdSsIdBuf);
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("BSSID:"), pTmpBssDesc->bdBssIdBuf);
if(tmp_power_diff > max_power_diff)
max_power_diff=tmp_power_diff;
if(tmp_power_diff < min_power_diff)
min_power_diff=tmp_power_diff;
}
else // Pow(Ant1) = Pow(Ant2)
{
if(pTestBssDesc->bdTstamp > pTmpBssDesc->bdTstamp) // Stamp(Ant1) < Stamp(Ant2)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("time_diff: %lld\n", (pTestBssDesc->bdTstamp-pTmpBssDesc->bdTstamp)/1000));
if(pTestBssDesc->bdTstamp - pTmpBssDesc->bdTstamp > 5000)
{
counter++;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Original: %d, Test: %d\n", pTmpBssDesc->RecvSignalPower, pTestBssDesc->RecvSignalPower));
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("SSID:"), pTmpBssDesc->bdSsIdBuf);
ODM_PRINT_ADDR(pDM_Odm,ODM_COMP_ANT_DIV, DBG_LOUD, ("BSSID:"), pTmpBssDesc->bdBssIdBuf);
min_power_diff = 0;
}
}
else
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("[Error !!!]: Time_diff: %lld\n", (pTestBssDesc->bdTstamp-pTmpBssDesc->bdTstamp)/1000));
}
}
}
}
}
if(pDM_Odm->SupportICType & (ODM_RTL8188E|ODM_RTL8821))
{
if(pMgntInfo->NumBssDesc!=0 && Score<0)
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink(): Using Ant(%s)\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"MAIN_ANT":"AUX_ANT"));
}
else
{
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,
("ODM_SwAntDivCheckBeforeLink(): Remain Ant(%s)\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"AUX_ANT":"MAIN_ANT"));
if(pDM_FatTable->RxIdleAnt == MAIN_ANT)
ODM_UpdateRxIdleAnt(pDM_Odm, AUX_ANT);
else
ODM_UpdateRxIdleAnt(pDM_Odm, MAIN_ANT);
}
if(IS_5G_WIRELESS_MODE(pMgntInfo->dot11CurrentWirelessMode))
{
pDM_SWAT_Table->Ant5G = pDM_FatTable->RxIdleAnt;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("pDM_SWAT_Table->Ant5G=%s\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"MAIN_ANT":"AUX_ANT"));
}
else
{
pDM_SWAT_Table->Ant2G = pDM_FatTable->RxIdleAnt;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("pDM_SWAT_Table->Ant2G=%s\n", (pDM_FatTable->RxIdleAnt==MAIN_ANT)?"MAIN_ANT":"AUX_ANT"));
}
}
else if(pDM_Odm->SupportICType == ODM_RTL8723B)
{
if(counter == 0)
{
if(pDM_Odm->DM_SWAT_Table.Pre_Aux_FailDetec == FALSE)
{
pDM_Odm->DM_SWAT_Table.Pre_Aux_FailDetec = TRUE;
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=FALSE;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Counter=(( 0 )) , [[ Cannot find any AP with Aux-ant ]] -> Scan Target-channel again \n"));
//3 [ Scan again ]
odm_SwAntDivConstructScanChnl(Adapter, ScanChannel);
PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
return TRUE;
}
else// Pre_Aux_FailDetec == TRUE
{
//2 [ Single Antenna ]
pDM_Odm->DM_SWAT_Table.Pre_Aux_FailDetec = FALSE;
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=TRUE;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("Counter=(( 0 )) , [[ Still cannot find any AP ]] \n"));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink(): Single antenna\n"));
}
pDM_Odm->DM_SWAT_Table.Aux_FailDetec_Counter++;
}
else
{
pDM_Odm->DM_SWAT_Table.Pre_Aux_FailDetec = FALSE;
if(counter==3)
{
avg_power_diff = ((power_diff-max_power_diff - min_power_diff)>>1)+ ((max_power_diff + min_power_diff)>>2);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("counter: (( %d )) , power_diff: (( %d )) \n", counter, power_diff));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("[ counter==3 ] Modified avg_power_diff: (( %d )) , max_power_diff: (( %d )) , min_power_diff: (( %d )) \n", avg_power_diff,max_power_diff, min_power_diff));
}
else if(counter>=4)
{
avg_power_diff=(power_diff-max_power_diff - min_power_diff) / (counter - 2);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("counter: (( %d )) , power_diff: (( %d )) \n", counter, power_diff));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("[ counter>=4 ] Modified avg_power_diff: (( %d )) , max_power_diff: (( %d )) , min_power_diff: (( %d )) \n", avg_power_diff,max_power_diff, min_power_diff));
}
else//counter==1,2
{
avg_power_diff=power_diff/counter;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("avg_power_diff: (( %d )) , counter: (( %d )) , power_diff: (( %d )) \n", avg_power_diff,counter, power_diff));
}
//2 [ Retry ]
if( (avg_power_diff >=power_target_L) && (avg_power_diff <=power_target_H) )
{
pDM_Odm->DM_SWAT_Table.Retry_Counter++;
if(pDM_Odm->DM_SWAT_Table.Retry_Counter<=3)
{
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=FALSE;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("[[ Low confidence result ]] avg_power_diff= (( %d )) -> Scan Target-channel again ]] \n", avg_power_diff));
//3 [ Scan again ]
odm_SwAntDivConstructScanChnl(Adapter, ScanChannel);
PlatformSetTimer(Adapter, &pMgntInfo->ScanTimer, 5);
return TRUE;
}
else
{
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=TRUE;
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("[[ Still Low confidence result ]] (( Retry_Counter > 3 )) \n"));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink(): Single antenna\n"));
}
}
//2 [ Dual Antenna ]
else if( (pMgntInfo->NumBssDesc != 0) && (avg_power_diff < power_target_L) )
{
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=TRUE;
if(pDM_Odm->DM_SWAT_Table.ANTB_ON == FALSE)
{
pDM_Odm->DM_SWAT_Table.ANTA_ON = TRUE;
pDM_Odm->DM_SWAT_Table.ANTB_ON = TRUE;
}
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("ODM_SwAntDivCheckBeforeLink(): Dual antenna\n"));
pDM_Odm->DM_SWAT_Table.Dual_Ant_Counter++;
// set bt coexDM from 1ant coexDM to 2ant coexDM
BT_SetBtCoexAntNum(Adapter, BT_COEX_ANT_TYPE_DETECTED, 2);
//3 [ Init antenna diversity ]
pDM_Odm->SupportAbility |= ODM_BB_ANT_DIV;
ODM_AntDivInit(pDM_Odm);
}
//2 [ Single Antenna ]
else if(avg_power_diff > power_target_H)
{
pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult=TRUE;
if(pDM_Odm->DM_SWAT_Table.ANTB_ON == TRUE)
{
pDM_Odm->DM_SWAT_Table.ANTA_ON = TRUE;
pDM_Odm->DM_SWAT_Table.ANTB_ON = FALSE;
//BT_SetBtCoexAntNum(Adapter, BT_COEX_ANT_TYPE_DETECTED, 1);
}
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("ODM_SwAntDivCheckBeforeLink(): Single antenna\n"));
pDM_Odm->DM_SWAT_Table.Single_Ant_Counter++;
}
}
//ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD, ("bResult=(( %d ))\n",pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("Dual_Ant_Counter = (( %d )), Single_Ant_Counter = (( %d )) , Retry_Counter = (( %d )) , Aux_FailDetec_Counter = (( %d ))\n\n\n",
pDM_Odm->DM_SWAT_Table.Dual_Ant_Counter,pDM_Odm->DM_SWAT_Table.Single_Ant_Counter,pDM_Odm->DM_SWAT_Table.Retry_Counter,pDM_Odm->DM_SWAT_Table.Aux_FailDetec_Counter));
//2 recover the antenna setting
if(pDM_Odm->DM_SWAT_Table.ANTB_ON == FALSE)
ODM_SetBBReg(pDM_Odm, rS0S1_PathSwitch, 0xfff, (pDM_SWAT_Table->SWAS_NoLink_BK_Reg948));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_ANT_DIV, ODM_DBG_LOUD,("bResult=(( %d )), Recover Reg[948]= (( %x )) \n\n",pDM_Odm->DM_SWAT_Table.RSSI_AntDect_bResult, pDM_SWAT_Table->SWAS_NoLink_BK_Reg948 ));
}
VOID
IndicateRxReorderList(
IN PADAPTER Adapter,
IN PRX_TS_RECORD pTS,
IN BOOLEAN bForced
)
{
PMGNT_INFO pMgntInfo = &Adapter->MgntInfo;
PRT_HIGH_THROUGHPUT pHTInfo = pMgntInfo->pHTInfo;
PRX_REORDER_ENTRY pReorderEntry = NULL;
u2Byte index = 0;
BOOLEAN bPktInBuf = FALSE;
// PRT_RFD pRfdIndicateArray[REORDER_WIN_SIZE];
PRT_RFD *pRfdIndicateArray;
PRT_GEN_TEMP_BUFFER pGenBuf;
Adapter->rxReorderIndEnterCnt++;
if(PlatformAtomicExchange(&Adapter->rxReorderRefCount, TRUE) == TRUE)
{
Adapter->rxReorderIndRejectCnt[0]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by AtomicExchange, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[0]));
return;
}
// Check if there is any other indication thread running.
if(pTS->RxIndicateState == RXTS_INDICATE_PROCESSING)
{
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
Adapter->rxReorderIndRejectCnt[1]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by RXTS_INDICATE_PROCESSING, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[1]));
return;
}
// Handling some condition for forced indicate case.
if(bForced)
{
if(RTIsListEmpty(&pTS->RxPendingPktList))
{
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
Adapter->rxReorderIndRejectCnt[2]++;
RT_TRACE(COMP_INIT, DBG_LOUD, ("IndicateRxReorderList(): There is already another thread running by ListEmpty, happened %d times!!!\n", Adapter->rxReorderIndRejectCnt[2]));
return;
}
else
{
pReorderEntry = (PRX_REORDER_ENTRY)RTGetHeadList(&pTS->RxPendingPktList);
pTS->RxIndicateSeq = pReorderEntry->SeqNum;
}
}
Adapter->rxReorderIndAllowCnt++;
pGenBuf = GetGenTempBuffer (Adapter, sizeof(PRT_RFD)*REORDER_WIN_SIZE);
pRfdIndicateArray = (PRT_RFD *)pGenBuf->Buffer.Ptr;
// Prepare indication list and indication.
do{
// Check if there is any packet need indicate.
while(!RTIsListEmpty(&pTS->RxPendingPktList))
{
pReorderEntry = (PRX_REORDER_ENTRY)RTGetHeadList(&pTS->RxPendingPktList);
if(!SN_LESS(pTS->RxIndicateSeq, pReorderEntry->SeqNum))
{
// This protect buffer from overflow.
if(index >= REORDER_WIN_SIZE)
{
RT_ASSERT(FALSE, ("IndicateRxReorderList(): Buffer overflow!! \n"));
bPktInBuf = TRUE;
break;
}
if(index > 0)
{
if(PlatformCompareMemory(pReorderEntry->pRfd->Address3,pRfdIndicateArray[index-1]->Address3,6) != 0)
{
bPktInBuf = TRUE;
break;
}
}
pReorderEntry = (PRX_REORDER_ENTRY)RTRemoveHeadList(&pTS->RxPendingPktList);
if(SN_EQUAL(pReorderEntry->SeqNum, pTS->RxIndicateSeq))
pTS->RxIndicateSeq = (pTS->RxIndicateSeq + 1) % 4096;
RT_TRACE(COMP_RX_REORDER, DBG_LOUD, ("RxReorderIndicatePacket(): Packets indication!! IndicateSeq: %d\n", pReorderEntry->SeqNum));
pRfdIndicateArray[index] = pReorderEntry->pRfd;
index++;
RTInsertTailList(&pMgntInfo->RxReorder_Unused_List, &pReorderEntry->List);
}
else
{
bPktInBuf = TRUE;
break;
}
}
// Handling pending timer. Set this timer to prevent from long time Rx buffering.
if(index>0)
{
// Cancel previous pending timer.
{
PlatformCancelTimer(Adapter, &pTS->RxPktPendingTimer);
// Set this as a lock to make sure that only one thread is indicating packet.
pTS->RxIndicateState = RXTS_INDICATE_PROCESSING;
}
// Indicate packets
RT_ASSERT((index<=REORDER_WIN_SIZE), ("RxReorderIndicatePacket(): Rx Reorder buffer full!! \n"));
// Packets indication.
DrvIFIndicatePackets(Adapter, pRfdIndicateArray, index);
// Update local variables.
//bPktInBuf = FALSE;
index = 0;
}
else
{
break;
}
}while(TRUE);
ReturnGenTempBuffer(Adapter, pGenBuf);
// Release the indication lock and set to new indication step.
if(bPktInBuf)
{
u1Byte set_penf_timer=FALSE;
{
if(pTS->RxIndicateState != RXTS_INDICATE_REORDER)
set_penf_timer = TRUE;
}
if (set_penf_timer == TRUE)
{
// Set new pending timer.
pTS->RxIndicateState = RXTS_INDICATE_REORDER;
PlatformSetTimer(Adapter, &pTS->RxPktPendingTimer, pHTInfo->RxReorderPendingTime);
}
}
else
{
pTS->RxIndicateState = RXTS_INDICATE_IDLE;
}
PlatformAtomicExchange(&Adapter->rxReorderRefCount, FALSE);
}
//
// This function set bandwidth mode in protocol layer.
//
VOID
CHNL_SetBwChnl(
IN PADAPTER pAdapter,
IN u1Byte PrimaryChnl,
IN CHANNEL_WIDTH Bandwidth,
IN EXTCHNL_OFFSET BwOffset
)
{
PMGNT_INFO pMgntInfo = &pAdapter->MgntInfo;
PRT_CHANNEL_INFO pChnlInfo = GET_CHNL_INFO(pMgntInfo);
PADAPTER DefAdapter = GetDefaultAdapter(pAdapter);
PMGNT_INFO pDefMgntInfo = &DefAdapter->MgntInfo;
PRT_CHANNEL_INFO pDefChnlInfo = GET_CHNL_INFO(pDefMgntInfo);
PCHANNEL_COMMON_CONTEXT pDefChnlCommInfo = DefAdapter->pPortCommonInfo->pChnlCommInfo;
CHANNEL_WIDTH ToSetBandWidth = CHANNEL_WIDTH_20;
EXTCHNL_OFFSET ToSTAExtChnlOffsetof40MHz= EXTCHNL_OFFSET_NO_EXT;
EXTCHNL_OFFSET ToSTAExtChnlOffsetof80MHz= EXTCHNL_OFFSET_NO_EXT;
u1Byte ToSTACenterFrequency;
RT_TRACE_F(COMP_SCAN, DBG_LOUD, ("PrimaryChnl %d\n", PrimaryChnl));
if(ACTING_AS_IBSS(DefAdapter))
{
{
// 2013/10/15 MH Add for higher adhoc and VHT 2.4G mode.
if (!pMgntInfo->bReg11nAdhoc && !pMgntInfo->bRegVht24g)
{
Bandwidth= CHANNEL_WIDTH_20;
BwOffset = EXTCHNL_OFFSET_NO_EXT;
}
}
}
ToSetBandWidth = Bandwidth;
ToSTAExtChnlOffsetof40MHz = BwOffset;
ToSTACenterFrequency = CHNL_GetCenterFrequency(PrimaryChnl, Bandwidth, BwOffset);
ToSetBandWidth = CHNL_CheckChnlPlanWithBW(pAdapter,PrimaryChnl,Bandwidth,BwOffset);
if((ToSetBandWidth != Bandwidth) && ToSetBandWidth==CHANNEL_WIDTH_20)
ToSTACenterFrequency =PrimaryChnl;
if(Bandwidth == CHANNEL_WIDTH_80)
{
if(ToSTACenterFrequency > pMgntInfo->dot11CurrentChannelNumber)
ToSTAExtChnlOffsetof80MHz = EXTCHNL_OFFSET_UPPER;
else if(ToSTACenterFrequency < pMgntInfo->dot11CurrentChannelNumber)
ToSTAExtChnlOffsetof80MHz = EXTCHNL_OFFSET_LOWER;
else
ToSTAExtChnlOffsetof80MHz = EXTCHNL_OFFSET_NO_EXT;
}
RT_DISP(FCHNL, FCHNL_FUN, ("Set ToSetBandWidth = %d, ToSTAExtChnlOffset = %d,ToSTAExtChnlOffsetof80MHz %d, ToSTACenterFrequency= %d \n", ToSetBandWidth, ToSTAExtChnlOffsetof40MHz,ToSTAExtChnlOffsetof80MHz,ToSTACenterFrequency));
pMgntInfo->dot11CurrentChannelBandWidth = ToSetBandWidth;
pChnlInfo->PrimaryChannelNumber = pDefChnlCommInfo->PrimaryChannelNumber = PrimaryChnl;
pChnlInfo->CurrentChannelBandWidth = pDefChnlCommInfo->CurrentChannelBandWidth = ToSetBandWidth;
pChnlInfo->CurrentChannelCenterFrequency = pDefChnlCommInfo->CurrentChannelCenterFrequency = ToSTACenterFrequency;
pChnlInfo->Ext20MHzChnlOffsetOf40MHz = pDefChnlCommInfo->Ext20MHzChnlOffsetOf40MHz = ToSTAExtChnlOffsetof40MHz;
pChnlInfo->Ext40MHzChnlOffsetOf80MHz = pDefChnlCommInfo->Ext40MHzChnlOffsetOf80MHz = ToSTAExtChnlOffsetof80MHz;
// TODO: 2007.7.13 by Emily Wait 2000ms in order to garantee that switching
// bandwidth is executed after scan is finished. It is a temporal solution
// because software should ganrantee the last operation of switching bandwidth
// is executed properlly.
if(!(RT_DRIVER_HALT(DefAdapter)))
PlatformSetTimer(DefAdapter, &pDefChnlInfo->SwBwTimer, 0);
FunctionOut(COMP_SCAN);
}
VOID
CHNL_SetBwChnlCallback(
IN PRT_TIMER pTimer
)
{
PADAPTER Adapter=(PADAPTER)pTimer->Adapter;
PMGNT_INFO pMgntInfo=&Adapter->MgntInfo;
PRT_CHANNEL_INFO pChnlInfo = pMgntInfo->pChannelInfo;
PHAL_DATA_TYPE pHalData = GET_HAL_DATA(Adapter);
BOOLEAN bSwBW = TRUE;
RT_DISP(FCHNL, FCHNL_FUN, ("===>%s \n", __FUNCTION__));
if(RT_DRIVER_HALT(Adapter))
{
RT_DISP(FCHNL, FCHNL_ERROR, ("<===%s bDriverStopped %d bSurpriseRemoved %d bDriverIsGoingToUnload %d\n", __FUNCTION__, Adapter->bDriverStopped, Adapter->bSurpriseRemoved, Adapter->bDriverIsGoingToUnload));
return;
}
if(Adapter->bInSetPower && RT_CANNOT_IO(Adapter))
{
RT_DISP(FCHNL, FCHNL_ERROR, ("<===%s can NOT IO\n", __FUNCTION__));
bSwBW = FALSE;
}
if(MgntResetOrPnPInProgress(Adapter))
{
RT_DISP(FCHNL, FCHNL_ERROR, ("<===%s MgntResetOrPnPInProgress\n", __FUNCTION__));
bSwBW = FALSE;
}
if(bSwBW == FALSE)
{
PlatformAcquireSpinLock(Adapter, RT_BW_SPINLOCK);
pChnlInfo->bSwBwInProgress = FALSE;
PlatformReleaseSpinLock(Adapter, RT_BW_SPINLOCK);
return;
}
if(MgntInitAdapterInProgress(pMgntInfo))
{
PlatformSetTimer(Adapter, &pChnlInfo->SwBwTimer, 100);
return;
}
if(RT_IsSwChnlAndBwInProgress(Adapter))
{
RT_DISP(FCHNL, FCHNL_FUN, ("<===%s pHalData->SwChnlInProgress: %d, pHalData->SetBWModeInProgress: %d, pHalData->bSwChnlAndSetBWInProgress: %d\n",
__FUNCTION__, pHalData->SwChnlInProgress, pHalData->SetBWModeInProgress, pHalData->bSwChnlAndSetBWInProgress));
PlatformSetTimer(Adapter, &pChnlInfo->SwBwTimer, 10);
return;
}
if(pMgntInfo->bScanInProgress)
{
RT_DISP(FCHNL, FCHNL_FUN, ("<===%s bScanInProgress\n", __FUNCTION__));
PlatformSetTimer(Adapter, &pChnlInfo->SwBwTimer, 10);
return;
}
if(!CHNL_AcquireOpLock(Adapter, CHNLOP_SWBW))
{
PlatformSetTimer(Adapter, &pChnlInfo->SwBwTimer, 10);
return;
}
if(IsDefaultAdapter(Adapter))
{
RT_DISP(FCHNL, FCHNL_FUN, ("%s Def Adapter \n", __FUNCTION__));
}
else
{
RT_DISP(FCHNL, FCHNL_FUN, ("%s Ext Adapter \n", __FUNCTION__));
}
PlatformAcquireSpinLock(Adapter, RT_BW_SPINLOCK);
pChnlInfo->bSwBwInProgress = TRUE;
PlatformReleaseSpinLock(Adapter, RT_BW_SPINLOCK);
chnl_HalSwBwChnl(Adapter);
// bandtype different only occur in 92d ; for 92c/92s last band type is the same as current band type
pHalData->LastBandType = pHalData->CurrentBandType;
PlatformAcquireSpinLock(Adapter, RT_BW_SPINLOCK);
pChnlInfo->bSwBwInProgress = FALSE;
PlatformReleaseSpinLock(Adapter, RT_BW_SPINLOCK);
CHNL_ReleaseOpLock(Adapter);
RT_DISP(FCHNL, FCHNL_FUN, ("<===%s\n", __FUNCTION__));
}