PADAPTER
MultiPortGetIdleExtAdapter(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PMULTIPORT_PORT_CONTEXT pMultiPort = MultiPortGetPortContext(pDefaultAdapter);
PRT_LIST_ENTRY pListEntry = RTNextEntryList(&pMultiPort->MultiList);
PADAPTER pExtAdapter = GetAdapterByListEntry(pListEntry);
while(!IsDefaultAdapter(pExtAdapter))
{
pMultiPort = MultiPortGetPortContext(pExtAdapter);
if(pMultiPort->bActiveAdapter == FALSE)
{
return pExtAdapter;
}
pListEntry = RTNextEntryList(&pMultiPort->MultiList);
pExtAdapter = GetAdapterByListEntry(pListEntry);
}
return NULL;
}
PADAPTER
GetFirstDevicePort(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PADAPTER pDevicePort = NULL;
pDevicePort = pDefaultAdapter;
while(pDevicePort != NULL)
{
#if P2P_SUPPORT == 1
if(P2P_ENABLED(GET_P2P_INFO(pDevicePort)))
{
if(P2P_ADAPTER_OS_SUPPORT_P2P(pDevicePort) && GET_P2P_INFO(pDevicePort)->Role == P2P_DEVICE)
break;
}
#endif
pDevicePort = GetNextExtAdapter(pDevicePort);
}
return pDevicePort;
}
PADAPTER
GetFirstGOPort(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PADAPTER pGOPort = NULL;
pGOPort = pDefaultAdapter;
while(pGOPort != NULL)
{
#if P2P_SUPPORT == 1
if(P2P_ENABLED(GET_P2P_INFO(pGOPort)))
{
if(GET_P2P_INFO(pGOPort)->Role == P2P_GO)
{
if(P2P_ADAPTER_RTK_SUPPORT_P2P(pGOPort))
{
pGOPort = GetFirstAPAdapter(pDefaultAdapter);
}
break;
}
}
#endif
pGOPort = GetNextExtAdapter(pGOPort);
}
return pGOPort;
}
PADAPTER
GetFirstClientPort(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PADAPTER pClientPort = NULL;
pClientPort = pDefaultAdapter;
while(pClientPort != NULL)
{
#if P2P_SUPPORT == 1
if(P2P_ENABLED(GET_P2P_INFO(pClientPort)))
{
if(GET_P2P_INFO(pClientPort)->Role == P2P_CLIENT)
break;
}
#endif
pClientPort = GetNextExtAdapter(pClientPort);
}
return pClientPort;
}
VOID
WPS_CopyRxEAPPacket(
IN PADAPTER Adapter,
IN PRT_RFD pRfd
)
{
PSIMPLE_CONFIG_T pSimpleConfig = GET_SIMPLE_CONFIG(&(GetDefaultAdapter(Adapter)->MgntInfo));
pu1Byte RecieveBufPtrt,RfdBufferPtr;
pu1Byte BufferPtr = (pu1Byte)&(pRfd->PacketLength );
RT_TRACE(COMP_WPS, DBG_LOUD, ("In WPS Copy EAP Packet\n"));
pRfd->PacketLength -= 18;//18 is the length we don't want
PlatformFillMemory(pSimpleConfig->RecieveBuf, 1500, 0);
PlatformMoveMemory(pSimpleConfig->RecieveBuf,BufferPtr, 2);
RecieveBufPtrt = (pu1Byte)pSimpleConfig->RecieveBuf+2;
RfdBufferPtr =pRfd->Buffer.VirtualAddress+4; //skip Version DATA TYPE fream control
PlatformMoveMemory(RecieveBufPtrt,RfdBufferPtr, ETHERNET_ADDRESS_LENGTH*2);
RecieveBufPtrt += (ETHERNET_ADDRESS_LENGTH*2);
RfdBufferPtr += (ETHERNET_ADDRESS_LENGTH*2);
RfdBufferPtr += 14;//Skip LLC Until 888E
if(pRfd->Buffer.VirtualAddress[0] & 0x80) {//Skip QoS
RfdBufferPtr += 2;
RT_TRACE(COMP_WPS, DBG_LOUD, ("The Data is %x and QoS is Set\n",RfdBufferPtr[0]));
pRfd->PacketLength -= 2;//18 is the length we don't want
PlatformMoveMemory(pSimpleConfig->RecieveBuf,BufferPtr, 2);
}
PlatformMoveMemory(RecieveBufPtrt,RfdBufferPtr,(pRfd->PacketLength -(ETHERNET_ADDRESS_LENGTH*2)) );
pSimpleConfig->bRecievePacket = TRUE;
pSimpleConfig->RecieveLength = (pRfd->PacketLength+2);// 2 is the packet length we reserved for report to lib
RT_PRINT_DATA(COMP_WPS, DBG_LOUD, "EAP Packet Content:", pSimpleConfig->RecieveBuf, pRfd->PacketLength);
}
VOID
WPS_Init(
IN PADAPTER Adapter
)
{
PSIMPLE_CONFIG_T pSimpleConfig = GET_SIMPLE_CONFIG(&(GetDefaultAdapter(Adapter)->MgntInfo));
Adapter->WPSSupport = TRUE;
pSimpleConfig->WpsIeVersion = SUPPORT_WPS_INFO_VERSION;
}
VOID
MultiportRecordLastScanTime(
IN PADAPTER pAdapter
)
{
u8Byte CurrTime = PlatformGetCurrentTime();
PADAPTER DefAdapter = GetDefaultAdapter(pAdapter);
DefAdapter->LastScanCompleteTime = CurrTime;
}
// Please do not use this function outside of this module
static PMULTIPORT_COMMON_CONTEXT
MultiPortGetCommonContext(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
RT_ASSERT(
sizeof(pDefaultAdapter->pPortCommonInfo->MultiPortCommon) == sizeof(MULTIPORT_COMMON_CONTEXT),
("MultiPort Common Context Memory Allocation Size Mismatch !")
);
return ((PMULTIPORT_COMMON_CONTEXT) pDefaultAdapter->pPortCommonInfo->MultiPortCommon);
}
//
// Description:
// Record the current scan complete time to all adapters.
// Arguments:
// [in] pAdapter -
// One of adapter list.
// Return:
// None
// Remark:
// This function save the current time as the scan complete mark into each
// adapter.
// The input adapter can be any one of the adapter list.
// By Bruce, 2012-03-02.
//
VOID
MultiportRecordLastScanTime(
IN PADAPTER pAdapter
)
{
PADAPTER pLoopAdapter = GetDefaultAdapter(pAdapter);
u8Byte CurrTime = PlatformGetCurrentTime();
while(pLoopAdapter)
{
pLoopAdapter->LastScanCompleteTime = CurrTime;
pLoopAdapter = GetNextExtAdapter(pLoopAdapter);
}
}
VOID
MultiPortSetAllPortsHWReadyStatus(
PADAPTER pAdapter,
BOOLEAN bReady
)
{
PADAPTER pLoopAdapter = GetDefaultAdapter(pAdapter);
RT_TRACE(COMP_INIT, DBG_LOUD, ("MultiPortSetAllPortsHWReadyStatus(), set pAdapter->bHWInitReady=%d\n", (u4Byte)bReady));
while(pLoopAdapter != NULL)
{
pLoopAdapter->bHWInitReady = bReady;
pLoopAdapter = GetNextExtAdapter(pLoopAdapter);
}
}
//
// Description:
// Get the primary channel from the channel information and hw configurations.
// Note:
// There are two kinds of channel, one is kept in mgnt/channel info and another one is kept in hal.
// They may be mismatched when the channel switching is in progress or scan in progress.
// When the scan is performing, the channel in mgnt/channel is not updated.
//
// If channels are different between HW and ChannelInfo, this function returns HW channel.
//
u1Byte
RT_GetChannelNumber(
IN PADAPTER pAdapter
)
{
u1Byte hwCenterChannel = 0;
EXTCHNL_OFFSET hwBW40MOffset = EXTCHNL_OFFSET_NO_EXT;
EXTCHNL_OFFSET hwBW80MOffset = EXTCHNL_OFFSET_NO_EXT;
pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_CUR_CENTER_CHNL, (pu1Byte)(&hwCenterChannel));
pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_BW40MHZ_EXTCHNL, (pu1Byte)(&hwBW40MOffset));
pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_BW80MHZ_EXTCHNL, (pu1Byte)(&hwBW80MOffset));
if(0 == hwCenterChannel)
{ // Please fix this case
hwCenterChannel = GET_HAL_DATA(pAdapter)->CurrentChannel;
RT_TRACE_F(COMP_SCAN, DBG_WARNING, ("[WARNING] Get hw channel = 0 by HW_VAR_CUR_CENTER_CHNL, access hal directly = %d\n",
hwCenterChannel));
}
if(((GetDefaultAdapter(pAdapter)->pPortCommonInfo->pChnlCommInfo->CurrentChannelCenterFrequency) == hwCenterChannel))
{
return (GetDefaultAdapter(pAdapter)->pPortCommonInfo->pChnlCommInfo->PrimaryChannelNumber);
}
else
{ // In this case, the returned channel may not be the right one because channel switching is in progress.
if((GetDefaultAdapter(pAdapter)->pPortCommonInfo->pChnlCommInfo->CurrentChannelCenterFrequency) != 0)
{
RT_TRACE_F(COMP_MLME, DBG_WARNING, ("[WARNING] Mismatched channel info ceter = %d, primary = %d, hwCenterChannel = %d (40M = %d, 80M = %d), SwChnlInProgress = %d, ScanInProgress = %d\n",
(GetDefaultAdapter(pAdapter)->pPortCommonInfo->pChnlCommInfo->CurrentChannelCenterFrequency),
(GetDefaultAdapter(pAdapter)->pPortCommonInfo->pChnlCommInfo->PrimaryChannelNumber),
hwCenterChannel, hwBW40MOffset, hwBW80MOffset, (RT_IsSwChnlAndBwInProgress(pAdapter) | CHNL_SwChnlAndSetBwInProgress(pAdapter)), MgntScanInProgress(&(pAdapter->MgntInfo))));
}
return hwCenterChannel;
}
}
BOOLEAN
IsAPModeExist(
PADAPTER Adapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(Adapter);
PADAPTER pAdapter = pDefaultAdapter;
while(pAdapter != NULL)
{
if(ACTING_AS_AP(pAdapter))
return TRUE;
pAdapter = GetNextExtAdapter(pAdapter);
}
return FALSE;
}
BOOLEAN
wps_IsWPSIEReady(
IN PADAPTER Adapter
)
{
PSIMPLE_CONFIG_T pSimpleConfig = GET_SIMPLE_CONFIG(&(GetDefaultAdapter(Adapter)->MgntInfo));
BOOLEAN wpsIEReady = FALSE;
if(pSimpleConfig->ieBeaconLen == 0 || pSimpleConfig->ieAsocReqLen == 0 || pSimpleConfig->ieAsocRspLen == 0
|| pSimpleConfig->ieProbeReqLen == 0 ||pSimpleConfig->ieProbeRspLen == 0)
{
return wpsIEReady;
}
wpsIEReady = TRUE;
return wpsIEReady;
}
BOOLEAN
IsActiveAPModeExist(
PADAPTER Adapter
)
{
PADAPTER pAdapter = GetDefaultAdapter(Adapter);
while(pAdapter != NULL)
{
if(AP_DetermineAlive(pAdapter))
return TRUE;
pAdapter = GetNextExtAdapter(pAdapter);
}
return FALSE;
}
PADAPTER
GetFirstAPAdapter(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PADAPTER pAPAdapter = pDefaultAdapter;
while(pAPAdapter != NULL)
{
if(ACTING_AS_AP(pAPAdapter))
break;
pAPAdapter = GetNextExtAdapter(pAPAdapter);
}
return pAPAdapter;
}
//
// Description:
// Get the latest time of connection action from current.
// Arguments:
// [in] pAdapter -
// One of adapter list.
// Return:
// Time in micro-seconds for the last connection action.
// Remark:
// If the returned value is 0, there's no recorded time of connection.
// By Bruce, 2015-02-10.
//
u8Byte
MultiportGetLastConnectionActionTime(
IN PADAPTER pAdapter
)
{
PADAPTER pLoopAdapter = GetDefaultAdapter(pAdapter);
u8Byte tmpConnectionActionTime = 0;
while(pLoopAdapter)
{
if(pLoopAdapter->LastConnectionActionTime > tmpConnectionActionTime)
tmpConnectionActionTime = pLoopAdapter->LastConnectionActionTime;
pLoopAdapter = GetNextExtAdapter(pLoopAdapter);
}
return tmpConnectionActionTime;
}
BOOLEAN
IsMultiPortAllowDisableHWSecurity(
PADAPTER Adapter
)
{
PADAPTER pAdapter = GetDefaultAdapter(Adapter);
PMGNT_INFO pMgntInfo = &(pAdapter->MgntInfo);;
while(pAdapter != NULL)
{
if(!pMgntInfo->SecurityInfo.SWTxEncryptFlag || !pMgntInfo->SecurityInfo.SWRxDecryptFlag)
return FALSE;
pAdapter = GetNextExtAdapter(pAdapter);
pMgntInfo = &(pAdapter->MgntInfo);
}
return TRUE;
}
PADAPTER
MultiPortRemoveExtAdapter(
PADAPTER pAdapter
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PMULTIPORT_PORT_CONTEXT pMultiPortDefault = MultiPortGetPortContext(pDefaultAdapter);
PADAPTER pExtAdapter = NULL;
PRT_LIST_ENTRY pListEntry = NULL;
if(!RTIsListEmpty(&pMultiPortDefault->MultiList))
{
pListEntry = RTRemoveHeadList(&pMultiPortDefault->MultiList);
pExtAdapter = GetAdapterByListEntry(pListEntry);
}
return pExtAdapter;
}
VOID
MultiPortReturnCloneRFD(
PADAPTER pAdapter,
PRT_RFD pRfd
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PMULTIPORT_COMMON_CONTEXT pMultiPortCommon = MultiPortGetCommonContext(pDefaultAdapter);
if(IsCloneRFD(pDefaultAdapter, pRfd))
{
RT_ASSERT(pRfd->bFeedPacketToSingleAdapter == TRUE, ("Error: Clone RFD may be returned again!\n"));
// Return the Multiport Clone RFDs -------------------------------------------
if(pRfd->bFeedPacketToSingleAdapter)
{
// Clean the MultiPort Flag
pRfd->bFeedPacketToSingleAdapter = FALSE;
// Return the data buffer
RT_ASSERT(pRfd->mbCloneRfdDataBuffer.Buffer != NULL, ("Multiport Clone RFD should have a data buffer!\n"));
DrvIFDisassociateRFD(pDefaultAdapter, pRfd);
PlatformAcquireSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
// Remove the RFD from Busy Queue
RTRemoveEntryListWithCnt(
&pRfd->List,
&pMultiPortCommon->uCloneRfdBusyQueueSize
);
// Return the RFD to the Idle Queue
RTInsertTailListWithCnt(
&pMultiPortCommon->CloneRfdIdleQueue,
&pRfd->List,
&pMultiPortCommon->uCloneRfdIdleQueueSize
);
PlatformReleaseSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
}
}
else
{
RT_TRACE(COMP_RECV, DBG_WARNING, ("This RFD is not CloneRFD: 0x%p!\n", pRfd));
}
}
//sherry added 20130207
//to check switch channel and bandwidth in progress
BOOLEAN
CHNL_SwChnlAndSetBwInProgress(
PADAPTER Adapter
)
{
PADAPTER pDefAdapter = GetDefaultAdapter(Adapter);
PMGNT_INFO pDefMgntInfo = &pDefAdapter->MgntInfo;
PRT_CHANNEL_INFO pDefChnlInfo = GET_CHNL_INFO(pDefMgntInfo);
if(pDefChnlInfo->bSwBwInProgress)
{
RT_DISP(FCHNL, FCHNL_INFO, ("%s: return TRUE \n", __FUNCTION__));
return TRUE;
}
else
{
RT_DISP(FCHNL, FCHNL_INFO, ("%s: return FALSE \n", __FUNCTION__));
return FALSE;
}
}
BOOLEAN
odm_IsConnected_92C(
IN PADAPTER Adapter
)
{
PRT_WLAN_STA pEntry;
PMGNT_INFO pMgntInfo = &(Adapter->MgntInfo);
u4Byte i;
BOOLEAN bConnected=FALSE;
if(pMgntInfo->mAssoc)
{
bConnected = TRUE;
}
else
{
for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
{
if(IsAPModeExist(Adapter) && GetFirstExtAdapter(Adapter) != NULL)
pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
else
pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
if(pEntry!=NULL)
{
if(pEntry->bAssociated)
{
bConnected = TRUE;
break;
}
}
else
{
break;
}
}
}
return bConnected;
}
BOOLEAN
WPS_OnAsocReq(
IN PADAPTER Adapter,
OUT BOOLEAN *pbIndicate
)
{
// PMGNT_INFO pMgntInfo = &(Adapter->MgntInfo);
PMGNT_INFO pDefaultMgntInfo = &(GetDefaultAdapter(Adapter)->MgntInfo);
PSIMPLE_CONFIG_T pSimpleConfig = GET_SIMPLE_CONFIG(pDefaultMgntInfo);
if(pSimpleConfig->bEnabled || pSimpleConfig->IELen > 0)
{// don't check RSNIE whenever WPS is enabled, 20100528, haich.
RT_TRACE_F(COMP_MLME, DBG_LOUD, ("Support WPS, don't indicate to OS!\n"));
*pbIndicate = FALSE;
}
else
{
RT_TRACE_F(COMP_MLME, DBG_LOUD, ("Check RSN-IE if necessary. return FALSE<====\n"));
return FALSE;
}
return TRUE;
}
VOID
MultiPortChangeExtAdapterActiveState(
PADAPTER pAdapter,
BOOLEAN bActive
)
{
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PMULTIPORT_COMMON_CONTEXT pMultiPortCommon = MultiPortGetCommonContext(pDefaultAdapter);
PMULTIPORT_PORT_CONTEXT pMultiPort = MultiPortGetPortContext(pAdapter);
RT_ASSERT(pMultiPort->bActiveAdapter != bActive, ("Same state changing is illegal !"));
pMultiPort->bActiveAdapter = bActive;
if(bActive)
{
pMultiPortCommon->uNumberOfActiveExtAdapters++;
}
else
{
pMultiPortCommon->uNumberOfActiveExtAdapters--;
}
}
VOID
WPS_ConstructBeaconFrame(
IN PADAPTER Adapter
)
{
//
// Simple config IE. by CCW - copy from 818x
//
PMGNT_INFO pMgntInfo = &(Adapter->MgntInfo);
PSIMPLE_CONFIG_T pSimpleConfig ;
OCTET_STRING SimpleConfigInfo;
PMGNT_INFO pDefaultMgntInfo;
if(ACTING_AS_IBSS(Adapter))
return;
if(!ACTING_AS_AP(Adapter))
return;
pDefaultMgntInfo = &(GetDefaultAdapter(Adapter)->MgntInfo);
pSimpleConfig = GET_SIMPLE_CONFIG(pDefaultMgntInfo);
if( ((pSimpleConfig->WpsIeVersion < SUPPORT_WPS_INFO_VERSION) || (wps_IsWPSIEReady(Adapter) == FALSE)) && pSimpleConfig->IELen > 0)
{ // Original method carrying WPS IE
RT_TRACE(COMP_WPS, DBG_TRACE, ("AP Construct Beacon \n"));
FillOctetString(SimpleConfigInfo, pSimpleConfig->IEBuf, pSimpleConfig->IELen);
PacketMakeElement( &pMgntInfo->beaconframe, EID_Vendor, SimpleConfigInfo);
}
else if(pSimpleConfig->WpsIeVersion == SUPPORT_WPS_INFO_VERSION)
{
FillOctetString(SimpleConfigInfo, pSimpleConfig->ieBeaconBuf, pSimpleConfig->ieBeaconLen);
if(pSimpleConfig->ieBeaconLen > 0)
PacketAppendData(&pMgntInfo->beaconframe, SimpleConfigInfo);
}
}
VOID
odm_CCKTXPathDiversity_92C(
IN PADAPTER Adapter
)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
PMGNT_INFO pMgntInfo = &(Adapter->MgntInfo);
PRT_WLAN_STA pEntry;
s4Byte MinRSSI = 0xFF;
u1Byte i, DefaultRespPath = 0;
// BOOLEAN bBModePathDiv = FALSE;
pPD_T pDM_PDTable = &Adapter->DM_PDTable;
//1 Default Port
if(pMgntInfo->mAssoc)
{
if(pHalData->OFDM_Pkt_Cnt == 0)
{
for(i=0; i<2; i++)
{
if(pDM_PDTable->RSSI_CCK_Path_cnt[i] > 1) //Because the first packet is discarded
pDM_PDTable->RSSI_CCK_Path[i] = pDM_PDTable->RSSI_CCK_Path[i] / (pDM_PDTable->RSSI_CCK_Path_cnt[i]-1);
else
pDM_PDTable->RSSI_CCK_Path[i] = 0;
}
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: pDM_PDTable->RSSI_CCK_Path[0]=%d, pDM_PDTable->RSSI_CCK_Path[1]=%d\n",
pDM_PDTable->RSSI_CCK_Path[0], pDM_PDTable->RSSI_CCK_Path[1]));
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",
pDM_PDTable->RSSI_CCK_Path_cnt[0], pDM_PDTable->RSSI_CCK_Path_cnt[1]));
if(pDM_PDTable->RSSI_CCK_Path[0] > pDM_PDTable->RSSI_CCK_Path[1])
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
MinRSSI = pDM_PDTable->RSSI_CCK_Path[1];
DefaultRespPath = 0;
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
}
else if(pDM_PDTable->RSSI_CCK_Path[0] < pDM_PDTable->RSSI_CCK_Path[1])
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath | BIT0;
MinRSSI = pDM_PDTable->RSSI_CCK_Path[0];
DefaultRespPath = 1;
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-1\n"));
}
else
{
if((pDM_PDTable->RSSI_CCK_Path[0] != 0) && (pDM_PDTable->RSSI_CCK_Path[0] < MinRSSI))
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & (~BIT0);
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port Select CCK Path-0\n"));
MinRSSI = pDM_PDTable->RSSI_CCK_Path[1];
DefaultRespPath = 0;
}
else
{
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Default port unchange CCK Path\n"));
}
}
}
else //Follow OFDM decision
{
pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~BIT0)) | (pDM_PDTable->OFDMTXPath &BIT0);
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, Default port Select CCK Path-%d\n",
pDM_PDTable->CCKTXPath &BIT0));
}
}
//1 Extension Port
for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
{
if(IsAPModeExist(Adapter) && GetFirstExtAdapter(Adapter) != NULL)
pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
else
pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
if(pEntry!=NULL)
{
if(pEntry->bAssociated)
{
if(pEntry->rssi_stat.OFDM_Pkt_Cnt == 0)
{
u1Byte j=0;
for(j=0; j<2; j++)
{
if(pEntry->rssi_stat.RSSI_CCK_Path_cnt[j] > 1)
pEntry->rssi_stat.RSSI_CCK_Path[j] = pEntry->rssi_stat.RSSI_CCK_Path[j] / (pEntry->rssi_stat.RSSI_CCK_Path_cnt[j]-1);
else
pEntry->rssi_stat.RSSI_CCK_Path[j] = 0;
}
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d, RSSI_CCK0=%d, RSSI_CCK1=%d\n",
pEntry->AssociatedMacId, pEntry->rssi_stat.RSSI_CCK_Path[0], pEntry->rssi_stat.RSSI_CCK_Path[1]));
if(pEntry->rssi_stat.RSSI_CCK_Path[0] >pEntry->rssi_stat.RSSI_CCK_Path[1])
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
if(pEntry->rssi_stat.RSSI_CCK_Path[1] < MinRSSI)
{
MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
DefaultRespPath = 0;
}
}
else if(pEntry->rssi_stat.RSSI_CCK_Path[0] <pEntry->rssi_stat.RSSI_CCK_Path[1])
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath | BIT(pEntry->AssociatedMacId);
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-1\n", pEntry->AssociatedMacId));
if(pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI)
{
MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[0];
DefaultRespPath = 1;
}
}
else
{
if((pEntry->rssi_stat.RSSI_CCK_Path[0] != 0) && (pEntry->rssi_stat.RSSI_CCK_Path[0] < MinRSSI))
{
pDM_PDTable->CCKTXPath = pDM_PDTable->CCKTXPath & ~(BIT(pEntry->AssociatedMacId));
MinRSSI = pEntry->rssi_stat.RSSI_CCK_Path[1];
DefaultRespPath = 0;
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d Select CCK Path-0\n", pEntry->AssociatedMacId));
}
else
{
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: MACID=%d unchange CCK Path\n", pEntry->AssociatedMacId));
}
}
}
else //Follow OFDM decision
{
pDM_PDTable->CCKTXPath = (pDM_PDTable->CCKTXPath & (~(BIT(pEntry->AssociatedMacId)))) | (pDM_PDTable->OFDMTXPath & BIT(pEntry->AssociatedMacId));
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_CCKTXPathDiversity_92C: Follow OFDM decision, MACID=%d Select CCK Path-%d\n",
pEntry->AssociatedMacId, (pDM_PDTable->CCKTXPath & BIT(pEntry->AssociatedMacId))>>(pEntry->AssociatedMacId)));
}
}
}
else
{
break;
}
}
VOID
odm_OFDMTXPathDiversity_92C(
IN PADAPTER Adapter)
{
// HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
PMGNT_INFO pMgntInfo = &(Adapter->MgntInfo);
PRT_WLAN_STA pEntry;
u1Byte i, DefaultRespPath = 0;
s4Byte MinRSSI = 0xFF;
pPD_T pDM_PDTable = &Adapter->DM_PDTable;
pDM_PDTable->OFDMTXPath = 0;
//1 Default Port
if(pMgntInfo->mAssoc)
{
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port RSSI[0]=%d, RSSI[1]=%d\n",
Adapter->RxStats.RxRSSIPercentage[0], Adapter->RxStats.RxRSSIPercentage[1]));
if(Adapter->RxStats.RxRSSIPercentage[0] > Adapter->RxStats.RxRSSIPercentage[1])
{
pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & (~BIT0);
MinRSSI = Adapter->RxStats.RxRSSIPercentage[1];
DefaultRespPath = 0;
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-0\n"));
}
else
{
pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath | BIT0;
MinRSSI = Adapter->RxStats.RxRSSIPercentage[0];
DefaultRespPath = 1;
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: Default port Select Path-1\n"));
}
//RT_TRACE( COMP_INIT, DBG_LOUD, ("pDM_PDTable->OFDMTXPath =0x%x\n",pDM_PDTable->OFDMTXPath));
}
//1 Extension Port
for(i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++)
{
if(IsAPModeExist(Adapter) && GetFirstExtAdapter(Adapter) != NULL)
pEntry = AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
else
pEntry = AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
if(pEntry!=NULL)
{
if(pEntry->bAssociated)
{
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d, RSSI_0=%d, RSSI_1=%d\n",
pEntry->AssociatedMacId, pEntry->rssi_stat.RxRSSIPercentage[0], pEntry->rssi_stat.RxRSSIPercentage[1]));
if(pEntry->rssi_stat.RxRSSIPercentage[0] > pEntry->rssi_stat.RxRSSIPercentage[1])
{
pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath & ~(BIT(pEntry->AssociatedMacId));
//pHalData->TXPath = pHalData->TXPath & ~(1<<(pEntry->AssociatedMacId));
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-0\n", pEntry->AssociatedMacId));
if(pEntry->rssi_stat.RxRSSIPercentage[1] < MinRSSI)
{
MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[1];
DefaultRespPath = 0;
}
}
else
{
pDM_PDTable->OFDMTXPath = pDM_PDTable->OFDMTXPath | BIT(pEntry->AssociatedMacId);
//pHalData->TXPath = pHalData->TXPath | (1 << (pEntry->AssociatedMacId));
RT_TRACE( COMP_INIT, DBG_LOUD, ("odm_OFDMTXPathDiversity_92C: MACID=%d Select Path-1\n", pEntry->AssociatedMacId));
if(pEntry->rssi_stat.RxRSSIPercentage[0] < MinRSSI)
{
MinRSSI = pEntry->rssi_stat.RxRSSIPercentage[0];
DefaultRespPath = 1;
}
}
}
}
else
{
break;
}
}
pDM_PDTable->OFDMDefaultRespPath = DefaultRespPath;
}
VOID
odm_DynamicPrimaryCCA(
IN PDM_ODM_T pDM_Odm
)
{
PADAPTER Adapter = pDM_Odm->Adapter; // for NIC
#if (DM_ODM_SUPPORT_TYPE & (ODM_WIN))
PRT_WLAN_STA pEntry;
#endif
PFALSE_ALARM_STATISTICS FalseAlmCnt = (PFALSE_ALARM_STATISTICS)PhyDM_Get_Structure( pDM_Odm , PHYDM_FALSEALMCNT);
pPri_CCA_T PrimaryCCA = &(pDM_Odm->DM_PriCCA);
BOOLEAN Is40MHz;
BOOLEAN Client_40MHz = FALSE, Client_tmp = FALSE; // connected client BW
BOOLEAN bConnected = FALSE; // connected or not
static u1Byte Client_40MHz_pre = 0;
static u8Byte lastTxOkCnt = 0;
static u8Byte lastRxOkCnt = 0;
static u4Byte Counter = 0;
static u1Byte Delay = 1;
u8Byte curTxOkCnt;
u8Byte curRxOkCnt;
u1Byte SecCHOffset;
u1Byte i;
if(!(pDM_Odm->SupportAbility & ODM_BB_PRIMARY_CCA))
return;
#if((DM_ODM_SUPPORT_TYPE==ODM_ADSL) ||( DM_ODM_SUPPORT_TYPE==ODM_CE))
return;
#else
if(pDM_Odm->SupportICType != ODM_RTL8188E)
return;
Is40MHz = *(pDM_Odm->pBandWidth);
SecCHOffset = *(pDM_Odm->pSecChOffset);
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("Second CH Offset = %d\n", SecCHOffset));
#if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
if(Is40MHz==1)
SecCHOffset = SecCHOffset%2+1; // NIC's definition is reverse to AP 1:secondary below, 2: secondary above
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("Second CH Offset = %d\n", SecCHOffset));
//3 Check Current WLAN Traffic
curTxOkCnt = Adapter->TxStats.NumTxBytesUnicast - lastTxOkCnt;
curRxOkCnt = Adapter->RxStats.NumRxBytesUnicast - lastRxOkCnt;
lastTxOkCnt = Adapter->TxStats.NumTxBytesUnicast;
lastRxOkCnt = Adapter->RxStats.NumRxBytesUnicast;
#elif (DM_ODM_SUPPORT_TYPE == ODM_AP)
//3 Check Current WLAN Traffic
curTxOkCnt = *(pDM_Odm->pNumTxBytesUnicast)-lastTxOkCnt;
curRxOkCnt = *(pDM_Odm->pNumRxBytesUnicast)-lastRxOkCnt;
lastTxOkCnt = *(pDM_Odm->pNumTxBytesUnicast);
lastRxOkCnt = *(pDM_Odm->pNumRxBytesUnicast);
#endif
//==================Debug Message====================
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("TP = %llu\n", curTxOkCnt+curRxOkCnt));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("Is40MHz = %d\n", Is40MHz));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("BW_LSC = %d\n", FalseAlmCnt->Cnt_BW_LSC));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("BW_USC = %d\n", FalseAlmCnt->Cnt_BW_USC));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("CCA OFDM = %d\n", FalseAlmCnt->Cnt_OFDM_CCA));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("CCA CCK = %d\n", FalseAlmCnt->Cnt_CCK_CCA));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("OFDM FA = %d\n", FalseAlmCnt->Cnt_Ofdm_fail));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("CCK FA = %d\n", FalseAlmCnt->Cnt_Cck_fail));
//================================================
#if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
if (ACTING_AS_AP(Adapter)) // primary cca process only do at AP mode
#endif
{
#if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("ACTING as AP mode=%d\n", ACTING_AS_AP(Adapter)));
//3 To get entry's connection and BW infomation status.
for(i=0;i<ASSOCIATE_ENTRY_NUM;i++)
{
if(IsAPModeExist(Adapter)&&GetFirstExtAdapter(Adapter)!=NULL)
pEntry=AsocEntry_EnumStation(GetFirstExtAdapter(Adapter), i);
else
pEntry=AsocEntry_EnumStation(GetDefaultAdapter(Adapter), i);
if(pEntry!=NULL)
{
Client_tmp = pEntry->BandWidth; // client BW
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("Client_BW=%d\n", Client_tmp));
if(Client_tmp>Client_40MHz)
Client_40MHz = Client_tmp; // 40M/20M coexist => 40M priority is High
if(pEntry->bAssociated)
{
bConnected=TRUE; // client is connected or not
break;
}
}
else
{
break;
}
}
#elif (DM_ODM_SUPPORT_TYPE == ODM_AP)
//3 To get entry's connection and BW infomation status.
PSTA_INFO_T pstat;
for(i=0; i<ODM_ASSOCIATE_ENTRY_NUM; i++)
{
pstat = pDM_Odm->pODM_StaInfo[i];
if(IS_STA_VALID(pstat) )
{
Client_tmp = pstat->tx_bw;
if(Client_tmp>Client_40MHz)
Client_40MHz = Client_tmp; // 40M/20M coexist => 40M priority is High
bConnected = TRUE;
}
}
#endif
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("bConnected=%d\n", bConnected));
ODM_RT_TRACE(pDM_Odm,ODM_COMP_DYNAMIC_PRICCA, ODM_DBG_LOUD, ("Is Client 40MHz=%d\n", Client_40MHz));
//1 Monitor whether the interference exists or not
if(PrimaryCCA->Monitor_flag == 1)
{
if(SecCHOffset == 1) // secondary channel is below the primary channel
{
if((FalseAlmCnt->Cnt_OFDM_CCA > 500)&&(FalseAlmCnt->Cnt_BW_LSC > FalseAlmCnt->Cnt_BW_USC+500))
{
if(FalseAlmCnt->Cnt_Ofdm_fail > FalseAlmCnt->Cnt_OFDM_CCA>>1)
{
PrimaryCCA->intf_type = 1;
PrimaryCCA->PriCCA_flag = 1;
ODM_SetBBReg(pDM_Odm, 0xc6c, BIT8|BIT7, 2); // USC MF
if(PrimaryCCA->DupRTS_flag == 1)
PrimaryCCA->DupRTS_flag = 0;
}
else
{
PrimaryCCA->intf_type = 2;
if(PrimaryCCA->DupRTS_flag == 0)
PrimaryCCA->DupRTS_flag = 1;
}
}
else // interferecne disappear
{
PrimaryCCA->DupRTS_flag = 0;
PrimaryCCA->intf_flag = 0;
PrimaryCCA->intf_type = 0;
}
}
else if(SecCHOffset == 2) // secondary channel is above the primary channel
int main(){
auto pLogger = CB::Log::CLogger::GetInstance();
pLogger->AddStream(CB::IO::File::Open(L"main.log", CB::IO::File::AccessType::WriteOnly, CB::IO::File::OpenAction::AlwaysCreate).Cast<CB::IO::IStream>());
pLogger->AddStream(CB::IO::Console::Create().Cast<CB::IO::IStream>(), CB::Log::CTextFormatter::Create(CB::String::Encoding::ANSI).Cast<CB::Log::IEntryFormatter>());
pLogger->SetDebugMode(true);
try{
auto pWinDriver = CB::Window::LoadDriver(L"MSWindowDriver");
auto pGraphicDriver = CB::Graphic::LoadDriver(L"OGLGraphicDriver");
{
auto pWinManager = pWinDriver->CreateManager();
auto pGraphicManager = pGraphicDriver->CreateManager(pWinManager);
CB::Math::CSize outSize(640, 480);
auto pWindow = pWinManager->CreateWindow(L"GraphicTest", CB::Window::Style::Single, outSize);
auto pGraphicAdapter = pGraphicManager->GetDefaultAdapter();
CB::Graphic::CDisplayMode dispMode(pWindow->GetSize(), 0, CB::Graphic::BufferFormat::B8G8R8X8);
CB::Graphic::CDeviceDesc devDesc(pWindow, dispMode, CB::Graphic::BufferFormat::D24S8, false);
CB::Collection::CList<CB::Graphic::FeatureLevel> featureLevels;
featureLevels.Add(CB::Graphic::FeatureLevel::Level_1);
auto pGraphicDevice = pGraphicAdapter->CreateDevice(pWindow, devDesc, featureLevels);
pWindow->OnClose += CB::Signals::CFunc<const bool, CB::CRefPtr<CB::Window::IWindow>>(CloseEvent);
pWindow->SetVisible(true);
CB::Graphic::CDepthStencilStateDesc depthDesc;
depthDesc.bDepthTestEnabled = true;
depthDesc.uDepthFunction = CB::Graphic::CompareFunc::LessEqual;
auto pDepthState = pGraphicDevice->CreateState(depthDesc);
pGraphicDevice->SetState(pDepthState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CRasterizerStateDesc rastDesc;
rastDesc.uCullMode = CB::Graphic::CullMode::None;
auto pRastState = pGraphicDevice->CreateState(rastDesc);
pGraphicDevice->SetState(pRastState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CBlendStateDesc blendDesc;
blendDesc.ColorBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.ColorBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.ColorBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.AlphaBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.AlphaBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.AlphaBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.bEnabled[0] = true;
auto pBlendState = pGraphicDevice->CreateState(blendDesc);
pGraphicDevice->SetState(pBlendState.Cast<CB::Graphic::IDeviceState>());
auto pFontManager = CB::Font::CManager::Create();
auto pFontStream = CB::IO::File::Open(L"Assets/font.ttf").Cast<CB::IO::IStream>();
auto pFont = pFontManager->Load(pFontStream);
pFont->SelectFace(0);
pFont->SetSize(24);
CB::Collection::CList<CB::Tools::CFontCharDesc> charDescs;
CB::Tools::CFontTextureGenerator fontGen(pGraphicDevice);
fontGen.MaxTextureSize.Set(512, 512);
auto pTexture = fontGen.Generate(pFont, charDescs);
CB::Tools::CTextMeshGenerator textGen(charDescs);
CB::Tools::CMeshRawIVT textMesh;
textGen.Generate(L"Marek M³ynarski!", textMesh);
CB::Collection::CList<CB::Graphic::CVertexElement> vEls;
vEls.Add(CB::Graphic::CVertexElement(0, L"vinput.vPosition", CB::Graphic::VertexType::Float, 3, 0));
vEls.Add(CB::Graphic::CVertexElement(1, L"vinput.vTexCoord", CB::Graphic::VertexType::Float, 2, 0));
GraphicTest::CShaderLoader shaders(pGraphicDevice, L"Shaders/TextureShader.cg");
auto pTextDecl = pGraphicDevice->CreateVertexDeclaration(shaders.pVertexShader, vEls);
auto pTextVertexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Vertices);
auto pTextTCoordBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.TexCoords);
auto pTextIndexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Index, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Indices);
float32 fAspect = (float32)outSize.Width / (float32)outSize.Height;
CB::Math::CMatrix mProj = CB::Math::CMatrix::GetPerspective(fAspect, 60.0f, 1.0f, 100.0f);
CB::Math::CMatrix mView = CB::Math::CMatrix::GetTranslation(-4.0f, 0.0f, -3.4f);
CB::Math::CMatrix mModel = CB::Math::CMatrix::GetIdentity();
shaders.pFragmentShader->SetSampler(L"texDiffuse", pTexture.Cast<CB::Graphic::IBaseTexture>());
pTexture->SetFilters(CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear);
pTexture->SetAnisotropy(8);
//g_pTexture = texture.pTexture;
while(g_bRun){
pGraphicDevice->Clear(1.0f, 1);
pGraphicDevice->Clear(CB::Math::CColor(1.0f, 0.5f, 0.0f, 1.0f));
pGraphicDevice->BeginRender();
pGraphicDevice->SetShader(shaders.pVertexShader);
pGraphicDevice->SetShader(shaders.pFragmentShader);
static float32 fV = 0.0f;
fV += 20 * g_Timer.GetTimeDelta();
mModel = CB::Math::CMatrix::GetRotation(CB::Math::AxisOrientation::AxisX, fV);
shaders.pVertexShader->SetUniform(L"vinput.mProj", mProj);
shaders.pVertexShader->SetUniform(L"vinput.mView", mView);
shaders.pVertexShader->SetUniform(L"vinput.mModel", mModel);
pGraphicDevice->SetVertexDeclaration(pTextDecl);
pGraphicDevice->SetVertexBuffer(0, pTextVertexBuffer);
pGraphicDevice->SetVertexBuffer(1, pTextTCoordBuffer);
pGraphicDevice->SetIndexBuffer(pTextIndexBuffer);
pGraphicDevice->RenderIndexed(textMesh.uNumberOfPolygons);
pGraphicDevice->EndRender();
g_Timer.Update();
pWinManager->ProcessEvents();
float fFPS = 1.0f / (g_Timer.GetTimeDelta() == 0.0f ? 1.0f : g_Timer.GetTimeDelta());
uint32 uFPS = (uint32)fFPS;
textMesh.Clear();
textGen.Generate(L"FPS: " + CB::String::ToString(uFPS), textMesh);
pTextVertexBuffer->LoadData(textMesh.Vertices);
pTextTCoordBuffer->LoadData(textMesh.TexCoords);
pTextIndexBuffer->LoadData(textMesh.Indices);
pGraphicDevice->Swap();
}
g_pTexture.Release();
}
}
catch(CB::Exception::CException& Exception){
CB::Log::Write(Exception, CB::Log::LogLevel::Fatal);
CB::Message::Show(Exception, CB::Message::Icon::Error);
}
return 0;
}
PADAPTER
MultiPortFeedPacketToMultipleAdapter(
PADAPTER pAdapter,
PRT_RFD pRfd
)
{
// NOTE: --------------------------------------------------------------
// If only single adapter is needed, return that adapter.
// --------------------------------------------------------------------
PADAPTER pDefaultAdapter = GetDefaultAdapter(pAdapter);
PMULTIPORT_COMMON_CONTEXT pMultiPortCommon = MultiPortGetCommonContext(pDefaultAdapter);
PADAPTER pExtAdapter = NULL;
PRT_RFD pExtRfd = NULL;
u4Byte i = 0;
RT_STATUS rtStatus = RT_STATUS_SUCCESS;
// Assertion Check Variable
u4Byte uCurrentCloneRFDs;
// Target List
u4Byte uTargetAdapter = 0;
PADAPTER TargetList[10];
// Single MPDU
OCTET_STRING frame = {NULL, 0};
FillOctetString(frame, pRfd->Buffer.VirtualAddress, pRfd->PacketLength);
if(pRfd->Status.bHwError)
{
RT_TRACE(COMP_RECV, DBG_TRACE, ("MultiPortFeedPacketToMultipleAdapter(): Return because bHwError is true.\n"));
return NULL;
}
// Information Source: pRfd Status Checking -------------------------------------------------------
RT_ASSERT(pRfd->Buffer.VirtualAddress != NULL, ("Error: pRfd->Buffer.VirtualAddress is NULL!\n"));
RT_ASSERT(pRfd->Buffer.Length != 0, ("Error: pRfd->Buffer.Length is 0!\n"));
RT_ASSERT(pRfd->PacketLength <= pRfd->Buffer.Length, ("Error: Packet Too Long!\n"));
// ------------------------------------------------------------------------------------------
// Clone RFD Status Checking ----------------------------------------------------------------------------------------------------------------------
PlatformAcquireSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
uCurrentCloneRFDs = pMultiPortCommon->uCloneRfdIdleQueueSize + pMultiPortCommon->uCloneRfdBusyQueueSize;
RT_ASSERT(uCurrentCloneRFDs == pMultiPortCommon->uNumberOfCloneRfds, ("Failure: Some Clone RFDs are Lost!uCurrentCloneRFDs=%d\n", uCurrentCloneRFDs));
PlatformReleaseSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
// ---------------------------------------------------------------------------------------------------------------------------------------------
// Get the target adapter list -----------------------------------------------------------------------------
uTargetAdapter = MultiPortGetTargetAdapterList(pAdapter, pRfd, frame, TargetList, sizeof(TargetList) / sizeof(PADAPTER));
//RT_TRACE(COMP_INIT, DBG_TRACE, ("%s: uTargetAdapter: %d \n", __FUNCTION__, uTargetAdapter));
if(uTargetAdapter == 0)
{
// Free the original RFD since the RFD is not necessary
RT_TRACE(COMP_INIT, DBG_TRACE, ("%s: No Target Adapter Found!\n", __FUNCTION__));
return NULL;
}
else if(uTargetAdapter == 1)
{
// Single adapter is needed. Do not free the original RFD, and run the original path
return TargetList[0];
}
// ----------------------------------------------------------------------------------------------------
// Send to each adapter
for(i = 0; i < uTargetAdapter; i++)
{
// Get the target adapter element
pExtAdapter = TargetList[i];
PlatformAcquireSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
if(RTIsListEmpty(&pMultiPortCommon->CloneRfdIdleQueue))
{
PlatformReleaseSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
RT_TRACE(COMP_INIT, DBG_SERIOUS, ("%s: No enough Clone RFD!\n", __FUNCTION__));
break;
}
// Acquire an idle Clone RFD and initialize the Clone RFD -----------------------------------------
pExtRfd = (PRT_RFD) RTRemoveHeadListWithCnt(
&pMultiPortCommon->CloneRfdIdleQueue,
&pMultiPortCommon->uCloneRfdIdleQueueSize
);
// + Clone the original information
PlatformZeroMemory(pExtRfd, sizeof(RT_RFD));
PlatformMoveMemory(pExtRfd, pRfd, sizeof(RT_RFD));
// + Record the needed memory length
pExtRfd->mbCloneRfdDataBuffer.Length = pRfd->Buffer.Length;
// + Allocate the memory based on the needed memory length above
rtStatus = DrvIFAssociateRFD(pDefaultAdapter, pExtRfd);
if(rtStatus != RT_STATUS_SUCCESS)
{
// Return the CloneRFD resource
RTInsertTailListWithCnt(
&pMultiPortCommon->CloneRfdIdleQueue,
&pExtRfd->List,
&pMultiPortCommon->uCloneRfdIdleQueueSize
);
PlatformReleaseSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
//RT_TRACE(COMP_INIT, DBG_SERIOUS, ("%s: No enough memory!\n", __FUNCTION__));
break;
}
//Sinda 20150903, Should assign Buffer's address according to it is clone RFD.
if(IsCloneRFD(pDefaultAdapter, pExtRfd))
{
// + Attach the memory to the CloneRFD
pExtRfd->Buffer.VirtualAddress = pExtRfd->mbCloneRfdDataBuffer.Buffer;
pExtRfd->Buffer.Length = pExtRfd->mbCloneRfdDataBuffer.Length;
}
#if RX_AGGREGATION
// + No Next RFD
pExtRfd->NextRfd = NULL;
// + Only Single MPDU Packet
pExtRfd->nTotalFrag = 1;
// + No Parent RFD
pExtRfd->ParentRfd = NULL;
// + Not in the USB temp RFD list: pAdapter->RfdTmpList
pExtRfd->bIsTemp = FALSE;
#endif
// Please be careful to handle pRfd->Buffer.VirtualAddress offset.
// + Move data
PlatformMoveMemory(
pExtRfd->Buffer.VirtualAddress,
pRfd->Buffer.VirtualAddress - pAdapter->HalFunc.GetRxPacketShiftBytesHandler(pRfd),
(pRfd->PacketLength + pAdapter->HalFunc.GetRxPacketShiftBytesHandler(pRfd))>pAdapter->MAX_RECEIVE_BUFFER_SIZE? pAdapter->MAX_RECEIVE_BUFFER_SIZE:(pRfd->PacketLength + pAdapter->HalFunc.GetRxPacketShiftBytesHandler(pRfd))
);
// + Get shifted bytes of starting address of 802.11 header (Sync the memory offset)
pExtRfd->Buffer.VirtualAddress += pAdapter->HalFunc.GetRxPacketShiftBytesHandler(pRfd);
// -------------------------------------------------------------------------------------
// Insert into busy Clone RFD queue
RTInsertHeadListWithCnt(
&pMultiPortCommon->CloneRfdBusyQueue,
&pExtRfd->List,
&pMultiPortCommon->uCloneRfdBusyQueueSize
);
PlatformReleaseSpinLock(pDefaultAdapter, RT_RFD_SPINLOCK);
// Iteration Flag
pExtRfd->bFeedPacketToSingleAdapter = TRUE;
// The pExtRfd will be free in ProcessReceivedPacket()
ProcessReceivedPacketForEachPortSpecific(pExtAdapter, pExtRfd);
}
// Free the original RFD since the CloneRFD is adopted.
return NULL;
}
u4Byte
MultiPortGetTargetAdapterList(
PADAPTER pAdapter,
PRT_RFD pRfd,
OCTET_STRING osFrame,
PADAPTER TargetList[],
u4Byte uMaxTarget
)
{
// Modified based on N62CSelectReceiveAdapter()
u4Byte uTargetAdapter = 0;
PADAPTER pExtAdapter = NULL;
PMGNT_INFO pExtMgntInfo = NULL;
BOOLEAN bMatch = FALSE;
if( pRfd->Status.PacketReportType == TX_REPORT2 ||
pRfd->Status.PacketReportType == C2H_PACKET)
{
pExtAdapter = GetDefaultAdapter(pAdapter);
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
return uTargetAdapter;
}
#if (P2P_SUPPORT == 1)
// Based on the frame content, determine if this adapter accepts the frame
if(P2PAdapterAcceptFrame(GetDefaultAdapter(pAdapter), osFrame))
{
MultiPortInsertIntoTargetAdapterList(GetDefaultAdapter(pAdapter), TargetList, &uTargetAdapter, uMaxTarget);
}
// Win8: Send packets to Device port --------------------------------------------------------------------
pExtAdapter = GetFirstDevicePort(pAdapter);
if(pExtAdapter != NULL)
{
// Based on the frame content, determine if this adapter accepts the frame
if(P2PAdapterAcceptFrame(pExtAdapter, osFrame))
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
}
}
if(PacketGetActionFrameType(&osFrame) == ACT_PKT_GAS_INT_REQ)
{// Service Discovery Request: Only Send to Device Port
// Here should have more consideration.
// Win7
pExtAdapter = GetDefaultAdapter(pAdapter);
if(P2P_ENABLED(GET_P2P_INFO(pExtAdapter)))
{
//if(GET_P2P_INFO(pExtAdapter)->Role == P2P_DEVICE) // this blocks the SD req when we are GO under Win7
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
}
}
// Win8
pExtAdapter = GetFirstDevicePort(pAdapter);
if(pExtAdapter != NULL)
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
}
return uTargetAdapter;
}
#endif
// Probe Request Filter
if(PacketGetType(osFrame) == Type_Probe_Req)
{
// Normal AP
pExtAdapter = GetDefaultAdapter(pAdapter);
while(pExtAdapter != NULL)
{
if(IN_SEND_BEACON_MODE(pExtAdapter ) || pExtAdapter->MgntInfo.bNetMonitorMode)
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
}
// Workaround for NdisTest-v8150 WFD_Group_ext test due to the SUT's not cleaning the resources ----------------
// The WFD_Performance_ext test will therefore have two device ports, which is not valid.
// We let it can be discovered for passing the test.
#if (P2P_SUPPORT == 1)
if(P2P_ENABLED(GET_P2P_INFO(pExtAdapter)))
{
if(GET_P2P_INFO(pExtAdapter)->Role == P2P_DEVICE)
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
}
}
#endif
// --------------------------------------------------------------------------------------------------
pExtAdapter = GetNextExtAdapter(pExtAdapter);
}
return uTargetAdapter;
}
// Probe Response Filter
RT_TRACE(COMP_P2P, DBG_TRACE, ("MultiPortGetTargetAdapterList: check probrsp\n"));
if(PacketGetType(osFrame) == Type_Probe_Rsp)
{
pExtAdapter = GetDefaultAdapter(pAdapter);
while(pExtAdapter != NULL)
{
pExtMgntInfo = &(pExtAdapter->MgntInfo);
if( ((pExtMgntInfo->state_Synchronization_Sta >= STATE_Act_Receive) ||
(pExtMgntInfo->state_Synchronization_Sta <= STATE_Act_Listen)) &&
eqMacAddr(Frame_pRaddr(osFrame), pExtAdapter->CurrentAddress)
)
{
RT_TRACE(COMP_P2P, DBG_TRACE, ("MultiPortGetTargetAdapterList listen state: port number %d\n", pExtAdapter->pNdis62Common->PortNumber));
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
bMatch = TRUE;
}
pExtAdapter = GetNextExtAdapter(pExtAdapter);
}
}
if(bMatch)
return uTargetAdapter;
if(PacketGetType(osFrame) == Type_Beacon)
{
// Broadcast Packet Filter , Beacon
pExtAdapter = GetDefaultAdapter(pAdapter);
while(pExtAdapter != NULL)
{
RT_TRACE(COMP_P2P, DBG_TRACE, ("MultiPortGetTargetAdapterList Broadcast\n"));
pExtMgntInfo = &(pExtAdapter->MgntInfo);
if( (pExtMgntInfo->state_Synchronization_Sta >= STATE_Act_Receive) ||
(pExtMgntInfo->state_Synchronization_Sta <= STATE_Act_Listen)
)
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
pExtAdapter = GetNextExtAdapter(pExtAdapter);
}
return uTargetAdapter;
}
bMatch = FALSE;
// BSSID Filter
RT_PRINT_ADDR(COMP_P2P, DBG_TRACE, "MultiPortGetTargetAdapterList(): receive Bss BSSID:", Frame_pBssid(osFrame));
pExtAdapter = GetDefaultAdapter(pAdapter);
while(pExtAdapter != NULL)
{
RT_PRINT_ADDR(COMP_P2P, DBG_TRACE, "MultiPortGetTargetAdapterList(): new Bss BSSID:", pExtAdapter->MgntInfo.Bssid);
RT_TRACE(COMP_P2P, DBG_TRACE, ("MultiPortGetTargetAdapterList: port number %d\n", pExtAdapter->pNdis62Common->PortNumber));
if(eqMacAddr(Frame_pBssid(osFrame), pExtAdapter->MgntInfo.Bssid))
{
RT_TRACE(COMP_P2P, DBG_TRACE, ("MultiPortGetTargetAdapterList eqMacAddr: port number %d\n", pExtAdapter->pNdis62Common->PortNumber));
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
bMatch = TRUE;
}
pExtAdapter = GetNextExtAdapter(pExtAdapter);
}
if(bMatch)
return uTargetAdapter;
// Broadcast Packet Filter
pExtAdapter = GetDefaultAdapter(pAdapter);
while(pExtAdapter != NULL)
{
MultiPortInsertIntoTargetAdapterList(pExtAdapter, TargetList, &uTargetAdapter, uMaxTarget);
pExtAdapter = GetNextExtAdapter(pExtAdapter);
}
return uTargetAdapter;
}
