blob: beb234f6ece2050b359951d1e235e9a24810d852 [file] [log] [blame]
/*
* rx.c
*
* Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Texas Instruments nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/***************************************************************************/
/* */
/* MODULE: Rx.c */
/* PURPOSE: Rx module functions */
/* */
/***************************************************************************/
#define __FILE_ID__ FILE_ID_54
#include "tidef.h"
#include "paramOut.h"
#include "rx.h"
#include "osApi.h"
#include "timer.h"
#include "DataCtrl_Api.h"
#include "Ctrl.h"
#include "802_11Defs.h"
#include "Ethernet.h"
#include "report.h"
#include "rate.h"
#include "mlmeApi.h"
#include "rsnApi.h"
#include "smeApi.h"
#include "siteMgrApi.h"
#include "GeneralUtil.h"
#include "EvHandler.h"
#ifdef XCC_MODULE_INCLUDED
#include "XCCMngr.h"
#endif
#include "TWDriver.h"
#include "RxBuf.h"
#include "DrvMainModules.h"
#include "bmtrace_api.h"
#include "PowerMgr_API.h"
#define EAPOL_PACKET 0x888E
#define IAPP_PACKET 0x0000
#define PREAUTH_EAPOL_PACKET 0x88C7
#define RX_DATA_FILTER_FLAG_NO_BIT_MASK 0
#define RX_DATA_FILTER_FLAG_USE_BIT_MASK 1
#define RX_DATA_FILTER_FLAG_IP_HEADER 0
#define RX_DATA_FILTER_FLAG_ETHERNET_HEADER 2
#define RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY 14
#define PADDING_ETH_PACKET_SIZE 2
/* CallBack for recieving packet from rxXfer */
static void rxData_ReceivePacket (TI_HANDLE hRxData, void *pBuffer);
static ERxBufferStatus rxData_RequestForBuffer (TI_HANDLE hRxData, void **pBuf, TI_UINT16 aLength, TI_UINT32 uEncryptionFlag,PacketClassTag_e ePacketClassTag);
#if 0
static TI_STATUS rxData_checkBssIdAndBssType(TI_HANDLE hRxData,
dot11_header_t* dot11_header,
TMacAddr **rxBssid,
ScanBssType_e *currBssType,
TMacAddr *currBssId);
#endif
static TI_STATUS rxData_convertWlanToEthHeader (TI_HANDLE hRxData, void *pBuffer, TI_UINT16 * etherType);
static TI_STATUS rxData_ConvertAmsduToEthPackets (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_dataPacketDisptcher (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_discardPacket (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_discardPacketVlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_rcvPacketInOpenNotify (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_rcvPacketEapol (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static void rxData_rcvPacketData (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
static TI_STATUS rxData_enableDisableRxDataFilters(TI_HANDLE hRxData, TI_BOOL enabled);
static TI_STATUS rxData_addRxDataFilter(TI_HANDLE hRxData, TRxDataFilterRequest* request);
static TI_STATUS rxData_removeRxDataFilter(TI_HANDLE hRxData, TRxDataFilterRequest* request);
#ifdef XCC_MODULE_INCLUDED
static void rxData_rcvPacketIapp(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
#endif
#ifdef TI_DBG
static void rxData_printRxThroughput(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured);
#endif
static void rxData_StartReAuthActiveTimer(TI_HANDLE hRxData);
static void reAuthTimeout(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured);
static void rxData_ReauthEnablePriority(TI_HANDLE hRxData);
/*************************************************************************
* rxData_create *
**************************************************************************
* DESCRIPTION: This function initializes the Rx data module.
*
* INPUT: hOs - handle to Os Abstraction Layer
*
* OUTPUT:
*
* RETURN: Handle to the allocated Rx data control block
************************************************************************/
TI_HANDLE rxData_create (TI_HANDLE hOs)
{
rxData_t *pRxData;
/* check parameters validity */
if (hOs == NULL)
{
WLAN_OS_REPORT(("FATAL ERROR: rxData_create(): OS handle Error - Aborting\n"));
return NULL;
}
/* alocate Rx module control block */
pRxData = os_memoryAlloc(hOs, (sizeof(rxData_t)));
if (!pRxData)
{
WLAN_OS_REPORT(("FATAL ERROR: rxData_create(): Error Creating Rx Module - Aborting\n"));
return NULL;
}
/* reset Rx control block */
os_memoryZero (hOs, pRxData, (sizeof(rxData_t)));
pRxData->RxEventDistributor = DistributorMgr_Create (hOs, MAX_RX_NOTIF_REQ_ELMENTS);
pRxData->hOs = hOs;
return (TI_HANDLE)pRxData;
}
/***************************************************************************
* rxData_config *
****************************************************************************
* DESCRIPTION: This function configures the Rx Data module
*
* INPUTS: pStadHandles - The driver modules handles
*
* OUTPUT:
*
* RETURNS: void
***************************************************************************/
void rxData_init (TStadHandlesList *pStadHandles)
{
rxData_t *pRxData = (rxData_t *)(pStadHandles->hRxData);
pRxData->hCtrlData = pStadHandles->hCtrlData;
pRxData->hTWD = pStadHandles->hTWD;
pRxData->hMlme = pStadHandles->hMlmeSm;
pRxData->hRsn = pStadHandles->hRsn;
pRxData->hSiteMgr = pStadHandles->hSiteMgr;
pRxData->hOs = pStadHandles->hOs;
pRxData->hReport = pStadHandles->hReport;
pRxData->hXCCMgr = pStadHandles->hXCCMngr;
pRxData->hEvHandler = pStadHandles->hEvHandler;
pRxData->hTimer = pStadHandles->hTimer;
pRxData->hPowerMgr = pStadHandles->hPowerMgr;
pRxData->rxDataExcludeUnencrypted = DEF_EXCLUDE_UNENCYPTED;
pRxData->rxDataExludeBroadcastUnencrypted = DEF_EXCLUDE_UNENCYPTED;
pRxData->rxDataEapolDestination = DEF_EAPOL_DESTINATION;
pRxData->rxDataPortStatus = DEF_RX_PORT_STATUS;
/*
* configure rx data dispatcher
*/
/* port status close */
pRxData->rxData_dispatchBuffer[CLOSE][DATA_DATA_PACKET] = &rxData_discardPacket; /* data */
pRxData->rxData_dispatchBuffer[CLOSE][DATA_EAPOL_PACKET] = &rxData_discardPacket; /* eapol */
pRxData->rxData_dispatchBuffer[CLOSE][DATA_IAPP_PACKET] = &rxData_discardPacket; /* Iapp */
pRxData->rxData_dispatchBuffer[CLOSE][DATA_VLAN_PACKET] = &rxData_discardPacketVlan; /* VLAN */
/* port status open notify */
pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_DATA_PACKET] = &rxData_rcvPacketInOpenNotify; /* data */
pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_EAPOL_PACKET] = &rxData_rcvPacketInOpenNotify; /* eapol */
pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_IAPP_PACKET] = &rxData_rcvPacketInOpenNotify; /* Iapp */
pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_VLAN_PACKET] = &rxData_discardPacketVlan; /* VLAN */
/* port status open eapol */
pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_DATA_PACKET] = &rxData_discardPacket; /* data */
pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_EAPOL_PACKET] = &rxData_rcvPacketEapol; /* eapol */
pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_IAPP_PACKET] = &rxData_discardPacket; /* Iapp */
pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_VLAN_PACKET] = &rxData_discardPacketVlan; /* VLAN */
/* port status open */
pRxData->rxData_dispatchBuffer[OPEN][DATA_DATA_PACKET] = &rxData_rcvPacketData; /* data */
pRxData->rxData_dispatchBuffer[OPEN][DATA_EAPOL_PACKET] = &rxData_rcvPacketEapol; /* eapol */
#ifdef XCC_MODULE_INCLUDED
pRxData->rxData_dispatchBuffer[OPEN][DATA_IAPP_PACKET] = &rxData_rcvPacketIapp; /* Iapp */
#else
pRxData->rxData_dispatchBuffer[OPEN][DATA_IAPP_PACKET] = &rxData_rcvPacketData; /* Iapp */
#endif
pRxData->rxData_dispatchBuffer[OPEN][DATA_VLAN_PACKET] = &rxData_discardPacketVlan;/* VLAN */
/* register CB's for request buffer and receive CB to the lower layers */
TWD_RegisterCb (pRxData->hTWD,
TWD_EVENT_RX_RECEIVE_PACKET,
(void *)rxData_ReceivePacket,
pStadHandles->hRxData);
TWD_RegisterCb (pRxData->hTWD,
TWD_EVENT_RX_REQUEST_FOR_BUFFER,
(void*)rxData_RequestForBuffer,
pStadHandles->hRxData);
}
TI_STATUS rxData_SetDefaults (TI_HANDLE hRxData, rxDataInitParams_t * rxDataInitParams)
{
rxData_t *pRxData = (rxData_t *)hRxData;
int i;
/* init rx data filters */
pRxData->filteringEnabled = rxDataInitParams->rxDataFiltersEnabled;
pRxData->filteringDefaultAction = rxDataInitParams->rxDataFiltersDefaultAction;
TWD_CfgEnableRxDataFilter (pRxData->hTWD, pRxData->filteringEnabled, pRxData->filteringDefaultAction);
for (i = 0; i < MAX_DATA_FILTERS; ++i)
{
if (rxDataInitParams->rxDataFilterRequests[i].maskLength > 0)
{
if (rxData_addRxDataFilter(hRxData, &rxDataInitParams->rxDataFilterRequests[i]) != TI_OK)
{
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid Rx Data Filter configured at init stage (at index %d)!\n", i);
}
}
}
pRxData->reAuthActiveTimer = tmr_CreateTimer (pRxData->hTimer);
if (pRxData->reAuthActiveTimer == NULL)
{
WLAN_OS_REPORT(("rxData_SetDefaults(): Failed to create reAuthActiveTimer!\n"));
return TI_NOK;
}
pRxData->reAuthActiveTimeout = rxDataInitParams->reAuthActiveTimeout;
rxData_SetReAuthInProgress(pRxData, TI_FALSE);
#ifdef TI_DBG
/* reset counters */
rxData_resetCounters(pRxData);
rxData_resetDbgCounters(pRxData);
/* allocate timer for debug throughput */
pRxData->hThroughputTimer = tmr_CreateTimer (pRxData->hTimer);
if (pRxData->hThroughputTimer == NULL)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_SetDefaults(): Failed to create hThroughputTimer!\n");
return TI_NOK;
}
pRxData->rxThroughputTimerEnable = TI_FALSE;
#endif
TRACE0(pRxData->hReport, REPORT_SEVERITY_INIT, ".....Rx Data configured successfully\n");
return TI_OK;
}
/***************************************************************************
* rxData_unLoad *
****************************************************************************
* DESCRIPTION: This function unload the Rx data module.
*
* INPUTS: hRxData - the object
*
* OUTPUT:
*
* RETURNS: TI_OK - Unload succesfull
* TI_NOK - Unload unsuccesfull
***************************************************************************/
TI_STATUS rxData_unLoad(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
/* check parameters validity */
if (pRxData == NULL)
{
return TI_NOK;
}
DistributorMgr_Destroy(pRxData->RxEventDistributor);
#ifdef TI_DBG
/* destroy periodic rx throughput timer */
if (pRxData->hThroughputTimer)
{
tmr_DestroyTimer (pRxData->hThroughputTimer);
}
#endif
if (pRxData->reAuthActiveTimer)
{
tmr_DestroyTimer (pRxData->reAuthActiveTimer);
}
/* free Rx Data controll block */
os_memoryFree(pRxData->hOs, pRxData, sizeof(rxData_t));
return TI_OK;
}
/***************************************************************************
* rxData_stop *
****************************************************************************
* DESCRIPTION: this function stop the rx data.
*
* INPUTS: hRxData - the object
*
* OUTPUT:
*
* RETURNS: TI_OK - stop succesfull
* TI_NOK - stop unsuccesfull
***************************************************************************/
TI_STATUS rxData_stop (TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
/* check parameters validity */
if (pRxData == NULL)
{
return TI_NOK;
}
pRxData->rxDataExcludeUnencrypted = DEF_EXCLUDE_UNENCYPTED;
pRxData->rxDataExludeBroadcastUnencrypted = DEF_EXCLUDE_UNENCYPTED;
pRxData->rxDataEapolDestination = DEF_EAPOL_DESTINATION;
pRxData->rxDataPortStatus = DEF_RX_PORT_STATUS;
#ifdef TI_DBG
/* reset counters */
/*rxData_resetCounters(pRxData);*/
/*rxData_resetDbgCounters(pRxData);*/
/* stop throughput timer */
if (pRxData->rxThroughputTimerEnable)
{
tmr_StopTimer (pRxData->hThroughputTimer);
pRxData->rxThroughputTimerEnable = TI_FALSE;
}
#endif
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_stop() : Succeeded.\n");
return TI_OK;
}
/***************************************************************************
* rxData_getParam *
****************************************************************************
* DESCRIPTION: get a specific parameter
*
* INPUTS: hRxData - the object
*
* OUTPUT: pParamInfo - structure which include the value of
* the requested parameter
*
* RETURNS: TI_OK
* TI_NOK
***************************************************************************/
TI_STATUS rxData_getParam(TI_HANDLE hRxData, paramInfo_t *pParamInfo)
{
rxData_t *pRxData = (rxData_t *)hRxData;
/* check handle validity */
if (pRxData == NULL)
{
return TI_NOK;
}
switch (pParamInfo->paramType)
{
case RX_DATA_EXCLUDE_UNENCRYPTED_PARAM:
pParamInfo->content.rxDataExcludeUnencrypted = pRxData->rxDataExcludeUnencrypted;
break;
case RX_DATA_EAPOL_DESTINATION_PARAM:
pParamInfo->content.rxDataEapolDestination = pRxData->rxDataEapolDestination;
break;
case RX_DATA_PORT_STATUS_PARAM:
pParamInfo->content.rxDataPortStatus = pRxData->rxDataPortStatus;
break;
case RX_DATA_COUNTERS_PARAM:
pParamInfo->content.siteMgrTiWlanCounters.RecvOk = pRxData->rxDataCounters.RecvOk;
pParamInfo->content.siteMgrTiWlanCounters.DirectedBytesRecv = pRxData->rxDataCounters.DirectedBytesRecv;
pParamInfo->content.siteMgrTiWlanCounters.DirectedFramesRecv = pRxData->rxDataCounters.DirectedFramesRecv;
pParamInfo->content.siteMgrTiWlanCounters.MulticastBytesRecv = pRxData->rxDataCounters.MulticastBytesRecv;
pParamInfo->content.siteMgrTiWlanCounters.MulticastFramesRecv = pRxData->rxDataCounters.MulticastFramesRecv;
pParamInfo->content.siteMgrTiWlanCounters.BroadcastBytesRecv = pRxData->rxDataCounters.BroadcastBytesRecv;
pParamInfo->content.siteMgrTiWlanCounters.BroadcastFramesRecv = pRxData->rxDataCounters.BroadcastFramesRecv;
break;
case RX_DATA_GET_RX_DATA_FILTERS_STATISTICS:
TWD_ItrDataFilterStatistics (pRxData->hTWD,
pParamInfo->content.interogateCmdCBParams.fCb,
pParamInfo->content.interogateCmdCBParams.hCb,
pParamInfo->content.interogateCmdCBParams.pCb);
break;
case RX_DATA_RATE_PARAM:
pParamInfo->content.siteMgrCurrentRxRate = pRxData->uLastDataPktRate;
break;
default:
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_getParam() : PARAMETER NOT SUPPORTED \n");
return (PARAM_NOT_SUPPORTED);
}
return TI_OK;
}
/***************************************************************************
* rxData_setParam *
****************************************************************************
* DESCRIPTION: set a specific parameter
*
* INPUTS: hRxData - the object
* pParamInfo - structure which include the value to set for
* the requested parameter
*
* OUTPUT:
*
* RETURNS: TI_OK
* TI_NOK
***************************************************************************/
TI_STATUS rxData_setParam(TI_HANDLE hRxData, paramInfo_t *pParamInfo)
{
rxData_t *pRxData = (rxData_t *)hRxData;
/* check handle validity */
if( pRxData == NULL )
{
return TI_NOK;
}
switch (pParamInfo->paramType)
{
case RX_DATA_EXCLUDE_UNENCRYPTED_PARAM:
pRxData->rxDataExcludeUnencrypted = pParamInfo->content.rxDataExcludeUnencrypted;
break;
case RX_DATA_EXCLUDE_BROADCAST_UNENCRYPTED_PARAM:
pRxData->rxDataExludeBroadcastUnencrypted = pParamInfo->content.rxDataExcludeUnencrypted;
break;
case RX_DATA_EAPOL_DESTINATION_PARAM:
pRxData->rxDataEapolDestination = pParamInfo->content.rxDataEapolDestination;
break;
case RX_DATA_PORT_STATUS_PARAM:
pRxData->rxDataPortStatus = pParamInfo->content.rxDataPortStatus;
break;
case RX_DATA_ENABLE_DISABLE_RX_DATA_FILTERS:
return rxData_enableDisableRxDataFilters(hRxData, pParamInfo->content.rxDataFilterEnableDisable);
case RX_DATA_ADD_RX_DATA_FILTER:
{
TRxDataFilterRequest* pRequest = &pParamInfo->content.rxDataFilterRequest;
return rxData_addRxDataFilter(hRxData, pRequest);
}
case RX_DATA_REMOVE_RX_DATA_FILTER:
{
TRxDataFilterRequest* pRequest = &pParamInfo->content.rxDataFilterRequest;
return rxData_removeRxDataFilter(hRxData, pRequest);
}
default:
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_setParam() : PARAMETER NOT SUPPORTED \n");
return (PARAM_NOT_SUPPORTED);
}
return TI_OK;
}
/***************************************************************************
* rxData_enableDisableRxDataFilters *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static TI_STATUS rxData_enableDisableRxDataFilters(TI_HANDLE hRxData, TI_BOOL enabled)
{
rxData_t * pRxData = (rxData_t *) hRxData;
/* assert 0 or 1 */
if (enabled != TI_FALSE)
enabled = 1;
if (enabled == pRxData->filteringEnabled)
return TI_OK;
pRxData->filteringEnabled = enabled;
return TWD_CfgEnableRxDataFilter (pRxData->hTWD, pRxData->filteringEnabled, pRxData->filteringDefaultAction);
}
/***************************************************************************
* findFilterRequest *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static int findFilterRequest(TI_HANDLE hRxData, TRxDataFilterRequest* request)
{
rxData_t * pRxData = (rxData_t *) hRxData;
int i;
for (i = 0; i < MAX_DATA_FILTERS; ++i)
{
if (pRxData->isFilterSet[i])
{
if ((pRxData->filterRequests[i].offset == request->offset) &&
(pRxData->filterRequests[i].maskLength == request->maskLength) &&
(pRxData->filterRequests[i].patternLength == request->patternLength))
{
if ((os_memoryCompare(pRxData->hOs, pRxData->filterRequests[i].mask, request->mask, request->maskLength) == 0) &&
(os_memoryCompare(pRxData->hOs, pRxData->filterRequests[i].pattern, request->pattern, request->patternLength) == 0))
return i;
}
}
}
return -1;
}
/***************************************************************************
* closeFieldPattern *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static void closeFieldPattern (rxData_t * pRxData, rxDataFilterFieldPattern_t * fieldPattern, TI_UINT8 * fieldPatterns, TI_UINT8 * lenFieldPatterns)
{
fieldPatterns[*lenFieldPatterns] = fieldPattern->offset;
*lenFieldPatterns += sizeof(fieldPattern->offset);
fieldPatterns[*lenFieldPatterns] = fieldPattern->length;
*lenFieldPatterns += sizeof(fieldPattern->length);
fieldPatterns[*lenFieldPatterns] = fieldPattern->flag;
*lenFieldPatterns += sizeof(fieldPattern->flag);
os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, fieldPattern->pattern, fieldPattern->length);
*lenFieldPatterns += fieldPattern->length;
/* if the pattern bit mask is enabled add it to the end of the request */
if ((fieldPattern->flag & RX_DATA_FILTER_FLAG_USE_BIT_MASK) == RX_DATA_FILTER_FLAG_USE_BIT_MASK)
{
os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, fieldPattern->mask, fieldPattern->length);
*lenFieldPatterns += fieldPattern->length;
}
TRACE3(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Closed field pattern, length = %d, total length = %d, pattern bit mask = %d.\n", fieldPattern->length, *lenFieldPatterns, ((fieldPattern->flag & RX_DATA_FILTER_FLAG_USE_BIT_MASK) == RX_DATA_FILTER_FLAG_USE_BIT_MASK));
}
/***************************************************************************
* parseRxDataFilterRequest *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static int parseRxDataFilterRequest(TI_HANDLE hRxData, TRxDataFilterRequest* request, TI_UINT8 * numFieldPatterns, TI_UINT8 * lenFieldPatterns, TI_UINT8 * fieldPatterns)
{
rxData_t * pRxData = (rxData_t *) hRxData;
int maskIter;
int patternIter = 0;
/* used to store field patterns while they are built */
TI_BOOL isBuildingFieldPattern = TI_FALSE;
rxDataFilterFieldPattern_t fieldPattern;
for (maskIter = 0; maskIter < request->maskLength * 8; ++maskIter)
{
/* which byte in the mask and which bit in the byte we're at */
int bit = maskIter % 8;
int byte = maskIter / 8;
/* is the bit in the mask set */
TI_BOOL isSet = ((request->mask[byte] & (1 << bit)) == (1 << bit));
TRACE4(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": MaskIter = %d, Byte = %d, Bit = %d, isSet = %d\n", maskIter, byte, bit, isSet);
/* if we're in the midst of building a field pattern, we need to close in case */
/* the current bit is not set or we've reached the ethernet header boundary */
if (isBuildingFieldPattern)
{
if ((isSet == TI_FALSE) || (request->offset + maskIter == RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY))
{
closeFieldPattern(hRxData, &fieldPattern, fieldPatterns, lenFieldPatterns);
isBuildingFieldPattern = TI_FALSE;
}
}
/* nothing to do in case the bit is not set */
if (isSet)
{
/* if not already building a field pattern, create a new one */
if (isBuildingFieldPattern == TI_FALSE)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Creating a new field pattern.\n");
isBuildingFieldPattern = TI_TRUE;
++(*numFieldPatterns);
if (*numFieldPatterns > RX_DATA_FILTER_MAX_FIELD_PATTERNS)
{
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, too many field patterns, maximum of %u is allowed!\n", RX_DATA_FILTER_MAX_FIELD_PATTERNS);
return TI_NOK;
}
fieldPattern.offset = request->offset + maskIter;
fieldPattern.length = 0;
/* we don't support the mask per bit feature yet. */
fieldPattern.flag = RX_DATA_FILTER_FLAG_NO_BIT_MASK;
/* first 14 bits are used for the Ethernet header, rest for the IP header */
if (fieldPattern.offset < RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY)
{
fieldPattern.flag |= RX_DATA_FILTER_FLAG_ETHERNET_HEADER;
}
else
{
fieldPattern.flag |= RX_DATA_FILTER_FLAG_IP_HEADER;
fieldPattern.offset -= RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY;
}
TRACE2(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": offset = %d, flag = %d.\n", fieldPattern.offset, fieldPattern.flag);
}
/* check that the pattern is long enough */
if (patternIter > request->patternLength)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, mask and pattern length are not consistent!\n");
return TI_NOK;
}
/* add the current pattern byte to the field pattern */
fieldPattern.pattern[fieldPattern.length++] = request->pattern[patternIter++];
/* check pattern matching boundary */
if (fieldPattern.offset + fieldPattern.length >= RX_DATA_FILTER_FILTER_BOUNDARY)
{
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, pattern matching cannot exceed first %u characters.\n", RX_DATA_FILTER_FILTER_BOUNDARY);
return TI_NOK;
}
}
}
/* check that the pattern is long enough */
if (patternIter != request->patternLength)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, mask and pattern lengths are not consistent!\n");
return TI_NOK;
}
/* close the last field pattern if needed */
if (isBuildingFieldPattern)
{
closeFieldPattern (hRxData, &fieldPattern, fieldPatterns, lenFieldPatterns);
}
return TI_OK;
}
/***************************************************************************
* rxData_setRxDataFilter *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static TI_STATUS rxData_addRxDataFilter (TI_HANDLE hRxData, TRxDataFilterRequest* request)
{
rxData_t * pRxData = (rxData_t *) hRxData;
/* firmware request fields */
TI_UINT8 index = 0;
TI_UINT8 numFieldPatterns = 0;
TI_UINT8 lenFieldPatterns = 0;
TI_UINT8 fieldPatterns[MAX_DATA_FILTER_SIZE];
/* does the filter already exist? */
if (findFilterRequest(hRxData, request) >= 0)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Filter already exists.\n");
return RX_FILTER_ALREADY_EXISTS;
}
/* find place for insertion */
for (index = 0; index < MAX_DATA_FILTERS; ++index)
{
if (pRxData->isFilterSet[index] == TI_FALSE)
break;
}
/* are all filter slots taken? */
if (index == MAX_DATA_FILTERS)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": No place to insert filter!\n");
return RX_NO_AVAILABLE_FILTERS;
}
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Inserting filter at index %d.\n", index);
/* parse the filter request into discrete field patterns */
if (parseRxDataFilterRequest(hRxData, request, &numFieldPatterns, &lenFieldPatterns, fieldPatterns) != TI_OK)
return TI_NOK;
if (numFieldPatterns == 0)
return TI_NOK;
/* Store configuration for future manipulation */
pRxData->isFilterSet[index] = TI_TRUE;
os_memoryCopy(pRxData->hOs, &pRxData->filterRequests[index], request, sizeof(pRxData->filterRequests[index]));
/* Send configuration to firmware */
return TWD_CfgRxDataFilter (pRxData->hTWD,
index,
ADD_FILTER,
FILTER_SIGNAL,
numFieldPatterns,
lenFieldPatterns,
fieldPatterns);
}
/***************************************************************************
* rxData_removeRxDataFilter *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static TI_STATUS rxData_removeRxDataFilter (TI_HANDLE hRxData, TRxDataFilterRequest* request)
{
rxData_t * pRxData = (rxData_t *) hRxData;
int index = findFilterRequest(hRxData, request);
/* does the filter exist? */
if (index < 0)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, ": Remove data filter request received but the specified filter was not found!");
return RX_FILTER_DOES_NOT_EXIST;
}
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Removing filter at index %d.", index);
pRxData->isFilterSet[index] = TI_FALSE;
return TWD_CfgRxDataFilter (pRxData->hTWD,
index,
REMOVE_FILTER,
FILTER_SIGNAL,
0,
0,
NULL);
}
/***************************************************************************
* rxData_DistributorRxEvent *
****************************************************************************
* DESCRIPTION:
*
*
* INPUTS:
*
*
*
* OUTPUT:
*
* RETURNS:
*
***************************************************************************/
static void rxData_DistributorRxEvent (rxData_t *pRxData, TI_UINT16 Mask, int DataLen)
{
DistributorMgr_EventCall (pRxData->RxEventDistributor, Mask, DataLen);
}
/***************************************************************************
* rxData_RegNotif *
****************************************************************************/
TI_HANDLE rxData_RegNotif (TI_HANDLE hRxData, TI_UINT16 EventMask, GeneralEventCall_t CallBack, TI_HANDLE context, TI_UINT32 Cookie)
{
rxData_t *pRxData = (rxData_t *)hRxData;
if (!hRxData)
return NULL;
return DistributorMgr_Reg (pRxData->RxEventDistributor, EventMask, (TI_HANDLE)CallBack, context, Cookie);
}
/***************************************************************************
* rxData_AddToNotifMask *
****************************************************************************/
TI_STATUS rxData_AddToNotifMask (TI_HANDLE hRxData, TI_HANDLE Notifh, TI_UINT16 EventMask)
{
rxData_t *pRxData = (rxData_t *)hRxData;
if (!hRxData)
return TI_NOK;
return DistributorMgr_AddToMask (pRxData->RxEventDistributor, Notifh, EventMask);
}
/***************************************************************************
* rxData_UnRegNotif *
****************************************************************************/
TI_STATUS rxData_UnRegNotif(TI_HANDLE hRxData,TI_HANDLE RegEventHandle)
{
rxData_t *pRxData = (rxData_t *)hRxData;
if (!hRxData)
return TI_NOK;
return DistributorMgr_UnReg (pRxData->RxEventDistributor, RegEventHandle);
}
/***************************************************************************
* rxData_receivePacketFromWlan *
****************************************************************************
* DESCRIPTION: this function is called by the GWSI for each received Buffer.
* It filter and distribute the received Buffer.
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
void rxData_receivePacketFromWlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TMacAddr address3;
dot11_header_t *pDot11Hdr;
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_receivePacketFromWlan() : pRxAttr->packetType = %d\n", pRxAttr->ePacketType);
switch (pRxAttr->ePacketType)
{
case TAG_CLASS_MANAGEMENT:
case TAG_CLASS_BCN_PRBRSP:
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_receivePacketFromWlan(): Received management Buffer len = %d\n", RX_BUF_LEN(pBuffer));
/* update siteMngr
*
* the BSSID in mgmt frames is always addr3 in the header
* must copy address3 since Buffer is freed in mlmeParser_recv
*/
pDot11Hdr = (dot11_header_t*)RX_BUF_DATA(pBuffer);
os_memoryCopy(pRxData->hOs, &address3, &pDot11Hdr->address3, sizeof(address3));
/* distribute mgmt pBuffer to mlme */
if( mlmeParser_recv(pRxData->hMlme, pBuffer, pRxAttr) != TI_OK )
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_receivePacketFromWlan() : MLME returned error \n");
}
break;
case TAG_CLASS_DATA:
case TAG_CLASS_QOS_DATA:
case TAG_CLASS_AMSDU:
case TAG_CLASS_EAPOL:
{
CL_TRACE_START_L3();
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_receivePacketFromWlan() : Received Data Buffer len = %d\n", RX_BUF_LEN(pBuffer));
/* send pBuffer to data dispatcher */
rxData_dataPacketDisptcher(hRxData, pBuffer, pRxAttr);
CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "RX", ".DataPacket");
break;
}
default:
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_receivePacketFromWlan(): Received unspecified packet type !!! \n");
RxBufFree(pRxData->hOs, pBuffer);
break;
}
}
/***************************************************************************
* rxData_dataPacketDisptcher *
****************************************************************************
* DESCRIPTION: this function is called upon receving data Buffer,
* it dispatches the packet to the approciate function according to
* data packet type and rx port status.
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_dataPacketDisptcher (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
portStatus_e DataPortStatus;
rxDataPacketType_e DataPacketType;
/* get rx port status */
DataPortStatus = pRxData->rxDataPortStatus;
/* discard data packets received while rx data port is closed */
if (DataPortStatus == CLOSE)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Data Buffer while Rx data port is closed \n");
rxData_discardPacket (hRxData, pBuffer, pRxAttr);
return;
}
/* get data packet type */
pRxData->uLastDataPktRate = pRxAttr->Rate; /* save Rx packet rate for statistics */
#ifdef XCC_MODULE_INCLUDED
if (XCCMngr_isIappPacket (pRxData->hXCCMgr, pBuffer) == TI_TRUE)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Iapp Buffer \n");
DataPacketType = DATA_IAPP_PACKET;
/* dispatch Buffer according to packet type and current rx data port status */
pRxData->rxData_dispatchBuffer[DataPortStatus][DataPacketType] (hRxData, pBuffer, pRxAttr);
}
else
#endif
{
/* A-MSDU ? */
if (TAG_CLASS_AMSDU == pRxAttr->ePacketType)
{
rxData_ConvertAmsduToEthPackets (hRxData, pBuffer, pRxAttr);
}
else
{
TI_UINT16 etherType = 0;
TEthernetHeader * pEthernetHeader;
/*
* if Host processes received packets, the header translation
* from WLAN to ETH is done here. The conversion has been moved
* here so that IAPP packets aren't converted.
*/
rxData_convertWlanToEthHeader (hRxData, pBuffer, &etherType);
pEthernetHeader = (TEthernetHeader *)RX_ETH_PKT_DATA(pBuffer);
if (etherType == ETHERTYPE_802_1D)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received VLAN packet \n");
DataPacketType = DATA_VLAN_PACKET;
}
else if (HTOWLANS(pEthernetHeader->type) == EAPOL_PACKET)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Eapol packet \n");
if (rxData_IsReAuthInProgress(pRxData))
{
/* ReAuth already in progress, restart timer */
rxData_StopReAuthActiveTimer(pRxData);
rxData_StartReAuthActiveTimer(pRxData);
}
else
{
if (PowerMgr_getReAuthActivePriority(pRxData->hPowerMgr))
{
/* ReAuth not in progress yet, force active, set flag, restart timer, send event */
rxData_SetReAuthInProgress(pRxData, TI_TRUE);
rxData_StartReAuthActiveTimer(pRxData);
rxData_ReauthEnablePriority(pRxData);
EvHandlerSendEvent(pRxData->hEvHandler, IPC_EVENT_RE_AUTH_STARTED, NULL, 0);
}
}
DataPacketType = DATA_EAPOL_PACKET;
}
else
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Data packet \n");
DataPacketType = DATA_DATA_PACKET;
}
/* dispatch Buffer according to packet type and current rx data port status */
pRxData->rxData_dispatchBuffer[DataPortStatus][DataPacketType] (hRxData, pBuffer, pRxAttr);
}
}
}
/***************************************************************************
* rxData_discardPacket *
****************************************************************************
* DESCRIPTION: this function is called to discard Buffer
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_discardPacket (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE2(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_discardPacket: rx port status = %d , Buffer status = %d \n", pRxData->rxDataPortStatus, pRxAttr->status);
pRxData->rxDataDbgCounters.excludedFrameCounter++;
/* free Buffer */
RxBufFree(pRxData->hOs, pBuffer);
}
/***************************************************************************
* rxData_discardPacketVlan *
****************************************************************************
* DESCRIPTION: this function is called to discard Buffer
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_discardPacketVlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_discardPacketVlan : drop packet that contains VLAN tag\n");
pRxData->rxDataDbgCounters.rxDroppedDueToVLANIncludedCnt++;
/* free Buffer */
RxBufFree(pRxData->hOs, pBuffer);
}
/***************************************************************************
* rxData_rcvPacketInOpenNotify *
****************************************************************************
* DESCRIPTION: this function is called upon receving data Eapol packet type
* while rx port status is "open notify"
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_rcvPacketInOpenNotify (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_rcvPacketInOpenNotify: receiving data packet while in rx port status is open notify\n");
pRxData->rxDataDbgCounters.rcvUnicastFrameInOpenNotify++;
/* free Buffer */
RxBufFree(pRxData->hOs, pBuffer);
}
/***************************************************************************
* rxData_rcvPacketEapol *
****************************************************************************
* DESCRIPTION: this function is called upon receving data Eapol packet type
* while rx port status is "open eapol"
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_rcvPacketEapol(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketEapol() : Received an EAPOL frame tranferred to OS\n");
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketEapol() : Received an EAPOL frame tranferred to OS\n");
EvHandlerSendEvent (pRxData->hEvHandler, IPC_EVENT_EAPOL, NULL, 0);
os_receivePacket (pRxData->hOs, pBuffer, (TI_UINT16)RX_ETH_PKT_LEN(pBuffer));
}
/***************************************************************************
* rxData_rcvPacketData *
****************************************************************************
* DESCRIPTION: this function is called upon receving data "data" packet type
* while rx port status is "open"
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
static void rxData_rcvPacketData(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TEthernetHeader *pEthernetHeader;
TI_UINT16 EventMask = 0;
TFwInfo *pFwInfo;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketData() : Received DATA frame tranferred to OS\n");
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketData() : Received DATA frame tranferred to OS\n");
/* check encryption status */
pEthernetHeader = (TEthernetHeader *)RX_ETH_PKT_DATA(pBuffer);
if (!MAC_MULTICAST (pEthernetHeader->dst))
{ /* unicast frame */
if((pRxData->rxDataExcludeUnencrypted) && (!(pRxAttr->packetInfo & RX_DESC_ENCRYPT_MASK)))
{
pRxData->rxDataDbgCounters.excludedFrameCounter++;
/* free Buffer */
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_rcvPacketData() : exclude unicast unencrypted is TI_TRUE & packet encryption is OFF\n");
RxBufFree(pRxData->hOs, pBuffer);
return;
}
}
else
{ /* broadcast frame */
if ((pRxData->rxDataExludeBroadcastUnencrypted) && (!(pRxAttr->packetInfo & RX_DESC_ENCRYPT_MASK)))
{
pRxData->rxDataDbgCounters.excludedFrameCounter++;
/* free Buffer */
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_rcvPacketData() : exclude broadcast unencrypted is TI_TRUE & packet encryption is OFF\n");
RxBufFree(pRxData->hOs, pBuffer);
return;
}
/*
* Discard multicast/broadcast frames that we sent ourselves.
* Per IEEE 802.11-2007 section 9.2.7: "STAs shall filter out
* broadcast/multicast messages that contain their address as
* the source address."
*/
pFwInfo = TWD_GetFWInfo (pRxData->hTWD);
if (MAC_EQUAL(pFwInfo->macAddress, pEthernetHeader->src))
{
pRxData->rxDataDbgCounters.excludedFrameCounter++;
/* free Buffer */
RxBufFree(pRxData->hOs, pBuffer);
return;
}
}
/* update traffic monitor parameters */
pRxData->rxDataCounters.RecvOk++;
EventMask |= RECV_OK;
if (!MAC_MULTICAST (pEthernetHeader->dst))
{
/* Directed frame */
pRxData->rxDataCounters.DirectedFramesRecv++;
pRxData->rxDataCounters.DirectedBytesRecv += RX_ETH_PKT_LEN(pBuffer);
EventMask |= DIRECTED_BYTES_RECV;
EventMask |= DIRECTED_FRAMES_RECV;
}
else if (MAC_BROADCAST (pEthernetHeader->dst))
{
/* Broadcast frame */
pRxData->rxDataCounters.BroadcastFramesRecv++;
pRxData->rxDataCounters.BroadcastBytesRecv += RX_ETH_PKT_LEN(pBuffer);
EventMask |= BROADCAST_BYTES_RECV;
EventMask |= BROADCAST_FRAMES_RECV;
}
else
{
/* Multicast Address */
pRxData->rxDataCounters.MulticastFramesRecv++;
pRxData->rxDataCounters.MulticastBytesRecv += RX_ETH_PKT_LEN(pBuffer);
EventMask |= MULTICAST_BYTES_RECV;
EventMask |= MULTICAST_FRAMES_RECV;
}
pRxData->rxDataCounters.LastSecBytesRecv += RX_ETH_PKT_LEN(pBuffer);
/*Handle PREAUTH_EAPOL_PACKET*/
if (HTOWLANS(pEthernetHeader->type) == PREAUTH_EAPOL_PACKET)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketData() : Received an Pre-Auth EAPOL frame tranferred to OS\n");
}
rxData_DistributorRxEvent (pRxData, EventMask, RX_ETH_PKT_LEN(pBuffer));
/* deliver packet to os */
os_receivePacket (pRxData->hOs, pBuffer, (TI_UINT16)RX_ETH_PKT_LEN(pBuffer));
}
/***************************************************************************
* rxData_rcvPacketIapp *
****************************************************************************
* DESCRIPTION: this function is called upon receving data IAPP packet type
* while rx port status is "open"
*
* INPUTS: hRxData - the object
* pBuffer - the received Buffer.
* pRxAttr - Rx attributes
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
#ifdef XCC_MODULE_INCLUDED
static void rxData_rcvPacketIapp(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketIapp() : Received IAPP frame tranferred to XCCMgr\n");
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketIapp() : Received IAPP frame tranferred to XCCMgr\n");
/* tranfer packet to XCCMgr */
XCCMngr_recvIAPPPacket (pRxData->hXCCMgr, pBuffer, pRxAttr);
/* free Buffer */
RxBufFree(pRxData->hOs, pBuffer);
}
#endif
/****************************************************************************
* rxData_convertWlanToEthHeader *
*****************************************************************************
* DESCRIPTION: this function convert the Packet header from 802.11 header
* format to ethernet format
*
* INPUTS: hRxData - the object
* pBuffer - the received pBuffer in 802.11 format
*
* OUTPUT: pEthPacket - pointer to the received pBuffer in ethernet format
* uEthLength - ethernet packet length
*
* RETURNS: TI_OK/TI_NOK
***************************************************************************/
static TI_STATUS rxData_convertWlanToEthHeader (TI_HANDLE hRxData, void *pBuffer, TI_UINT16 * etherType)
{
TEthernetHeader EthHeader;
Wlan_LlcHeader_T *pWlanSnapHeader;
TI_UINT8 *dataBuf;
dot11_header_t *pDot11Header;
TI_UINT32 lengthDelta;
TI_UINT16 swapedTypeLength;
TI_UINT32 headerLength;
TI_UINT8 createEtherIIHeader;
rxData_t *pRxData = (rxData_t *)hRxData;
dataBuf = (TI_UINT8 *)RX_BUF_DATA(pBuffer);
/* Setting the mac header len according to the received FrameControl field in the Mac Header */
GET_MAX_HEADER_SIZE (dataBuf, &headerLength);
pDot11Header = (dot11_header_t*) dataBuf;
pWlanSnapHeader = (Wlan_LlcHeader_T*)((TI_UINT32)dataBuf + (TI_UINT32)headerLength);
swapedTypeLength = WLANTOHS (pWlanSnapHeader->Type);
*etherType = swapedTypeLength;
/* Prepare the Ethernet header. */
if( ENDIAN_HANDLE_WORD(pDot11Header->fc) & DOT11_FC_FROM_DS)
{ /* Infrastructure bss */
MAC_COPY (EthHeader.dst, pDot11Header->address1);
MAC_COPY (EthHeader.src, pDot11Header->address3);
}
else
{ /* Independent bss */
MAC_COPY (EthHeader.dst, pDot11Header->address1);
MAC_COPY (EthHeader.src, pDot11Header->address2);
}
createEtherIIHeader = TI_FALSE;
/* See if the LLC header in the frame shows the SAP SNAP... */
if((SNAP_CHANNEL_ID == pWlanSnapHeader->DSAP) &&
(SNAP_CHANNEL_ID == pWlanSnapHeader->SSAP) &&
(LLC_CONTROL_UNNUMBERED_INFORMATION == pWlanSnapHeader->Control))
{
/* Check for the Bridge Tunnel OUI in the SNAP Header... */
if((SNAP_OUI_802_1H_BYTE0 == pWlanSnapHeader->OUI[ 0 ]) &&
(SNAP_OUI_802_1H_BYTE1 == pWlanSnapHeader->OUI[ 1 ]) &&
(SNAP_OUI_802_1H_BYTE2 == pWlanSnapHeader->OUI[ 2 ]))
{
/* Strip the SNAP header by skipping over it. */
/* Start moving data from the Ethertype field in the SNAP */
/* header. Move to the TypeLength field in the 802.3 header. */
createEtherIIHeader = TI_TRUE;
}
/* Check for the RFC 1042 OUI in the SNAP Header */
else
{
/* Check for the RFC 1042 OUI in the SNAP Header */
if( (SNAP_OUI_RFC1042_BYTE0 == pWlanSnapHeader->OUI[ 0 ]) &&
(SNAP_OUI_RFC1042_BYTE1 == pWlanSnapHeader->OUI[ 1 ]) &&
(SNAP_OUI_RFC1042_BYTE2 == pWlanSnapHeader->OUI[ 2 ]))
{
/* See if the Ethertype is in our selective translation table */
/* (Appletalk AARP and DIX II IPX are the two protocols in */
/* our 'table') */
if((ETHERTYPE_APPLE_AARP != swapedTypeLength) &&
(ETHERTYPE_DIX_II_IPX != swapedTypeLength))
{
/* Strip the SNAP header by skipping over it. */
createEtherIIHeader = TI_TRUE;
}
}
}
}
if( createEtherIIHeader == TI_TRUE )
{
/* The LEN/TYPE bytes are set to TYPE, the entire WLAN+SNAP is removed.*/
lengthDelta = headerLength + WLAN_SNAP_HDR_LEN - ETHERNET_HDR_LEN;
EthHeader.type = pWlanSnapHeader->Type;
}
else
{
/* The LEN/TYPE bytes are set to frame LEN, only the WLAN header is removed, */
/* the entire 802.3 or 802.2 header is not removed.*/
lengthDelta = headerLength - ETHERNET_HDR_LEN;
EthHeader.type = WLANTOHS((TI_UINT16)(RX_BUF_LEN(pBuffer) - headerLength));
}
/* Replace the 802.11 header and the LLC with Ethernet packet. */
dataBuf += lengthDelta;
os_memoryCopy (pRxData->hOs, dataBuf, (void*)&EthHeader, ETHERNET_HDR_LEN);
RX_ETH_PKT_DATA(pBuffer) = dataBuf;
RX_ETH_PKT_LEN(pBuffer) = RX_BUF_LEN(pBuffer) - lengthDelta;
return TI_OK;
}
/**
* \brief convert A-MSDU to several ethernet packets
*
* \param hRxData - the object
* \param pBuffer - the received Buffer in A-MSDU 802.11n format
* \param pRxAttr - Rx attributes
* \return TI_OK on success or TI_NOK on failure
*
* \par Description
* Static function
* This function convert the A-MSDU Packet from A-MSDU 802.11n packet
* format to several ethernet packets format and pass them to the OS layer
*
* \sa
*/
static TI_STATUS rxData_ConvertAmsduToEthPackets (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
{
TEthernetHeader *pMsduEthHeader;
TEthernetHeader *pEthHeader;
Wlan_LlcHeader_T *pWlanSnapHeader;
TI_UINT8 *pAmsduDataBuf;
TI_UINT16 uAmsduDataLen;
void *pDataBuf;
TI_UINT16 uDataLen;
TI_UINT32 lengthDelta;
TI_UINT16 swapedTypeLength;
TI_UINT32 headerLength;
rxDataPacketType_e DataPacketType;
rxData_t *pRxData = (rxData_t *)hRxData;
/* total AMPDU header */
pAmsduDataBuf = (TI_UINT8 *)RX_BUF_DATA(pBuffer);
/* Setting the mac header len according to the received FrameControl field in the Mac Header */
GET_MAX_HEADER_SIZE (pAmsduDataBuf, &headerLength);
/*
* init loop setting
*/
/* total AMPDU size */
uAmsduDataLen = (TI_UINT16)(RX_BUF_LEN(pBuffer) - headerLength);
/* ETH header */
pMsduEthHeader = (TEthernetHeader *)(pAmsduDataBuf + headerLength);
/* ETH length, in A-MSDU the MSDU header type contain the MSDU length and not the type */
uDataLen = WLANTOHS(pMsduEthHeader->type);
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ConvertAmsduToEthPackets(): A-MSDU received in length %d \n",uAmsduDataLen);
/* if we have another packet at the AMSDU */
while((uDataLen < uAmsduDataLen) && (uAmsduDataLen > ETHERNET_HDR_LEN + FCS_SIZE))
{
/* allocate a new buffer */
/* RxBufAlloc() add an extra word for alignment the MAC payload */
rxData_RequestForBuffer (hRxData, &pDataBuf, sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen, 0, TAG_CLASS_AMSDU);
if (NULL == pDataBuf)
{
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ConvertAmsduToEthPackets(): cannot alloc MSDU packet. length %d \n",uDataLen);
rxData_discardPacket (hRxData, pBuffer, pRxAttr);
return TI_NOK;
}
/* read packet type from LLC */
pWlanSnapHeader = (Wlan_LlcHeader_T*)((TI_UINT8*)pMsduEthHeader + ETHERNET_HDR_LEN);
swapedTypeLength = WLANTOHS (pWlanSnapHeader->Type);
/* copy the RxIfDescriptor */
os_memoryCopy (pRxData->hOs, pDataBuf, pBuffer, sizeof(RxIfDescriptor_t));
/* update length, in the RxIfDescriptor the Len in words (4B) */
((RxIfDescriptor_t *)pDataBuf)->length = (sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen) >> 2;
((RxIfDescriptor_t *)pDataBuf)->extraBytes = 4 - ((sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen) & 0x3);
/* Prepare the Ethernet header pointer. */
/* add padding in the start of the buffer in order to align ETH payload */
pEthHeader = (TEthernetHeader *)((TI_UINT8 *)(RX_BUF_DATA(pDataBuf)) +
WLAN_SNAP_HDR_LEN +
PADDING_ETH_PACKET_SIZE);
/* copy the Ethernet header */
os_memoryCopy (pRxData->hOs, pEthHeader, pMsduEthHeader, ETHERNET_HDR_LEN);
/* The LEN/TYPE bytes are set to TYPE */
pEthHeader->type = pWlanSnapHeader->Type;
/* Delta length for the next packet */
lengthDelta = ETHERNET_HDR_LEN + uDataLen;
/* copy the packet payload */
if (uDataLen > WLAN_SNAP_HDR_LEN)
os_memoryCopy (pRxData->hOs,
(((TI_UINT8*)pEthHeader) + ETHERNET_HDR_LEN),
((TI_UINT8*)pMsduEthHeader) + ETHERNET_HDR_LEN + WLAN_SNAP_HDR_LEN,
uDataLen - WLAN_SNAP_HDR_LEN);
/* set the packet type */
if (swapedTypeLength == ETHERTYPE_802_1D)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received VLAN Buffer \n");
DataPacketType = DATA_VLAN_PACKET;
}
else if (HTOWLANS(pEthHeader->type) == EAPOL_PACKET)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received Eapol pBuffer \n");
DataPacketType = DATA_EAPOL_PACKET;
}
else
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received Data pBuffer \n");
DataPacketType = DATA_DATA_PACKET;
}
/* update buffer setting */
/* save the ETH packet address */
RX_ETH_PKT_DATA(pDataBuf) = pEthHeader;
/* save the ETH packet size */
RX_ETH_PKT_LEN(pDataBuf) = uDataLen + ETHERNET_HDR_LEN - WLAN_SNAP_HDR_LEN;
/* dispatch Buffer according to packet type and current rx data port status */
pRxData->rxData_dispatchBuffer[pRxData->rxDataPortStatus][DataPacketType] (hRxData, pDataBuf, pRxAttr);
/* star of MSDU packet always align acceding to 11n spec */
lengthDelta = (lengthDelta + ALIGN_4BYTE_MASK) & ~ALIGN_4BYTE_MASK;
pMsduEthHeader = (TEthernetHeader *)(((TI_UINT8*)pMsduEthHeader) + lengthDelta);
if(uAmsduDataLen > lengthDelta)
{
/* swich to the next MSDU */
uAmsduDataLen = uAmsduDataLen - lengthDelta;
}
else
{
/* no more MSDU */
uAmsduDataLen = 0;
break;
}
/* in A-MSDU the MSDU header type contain the MSDU length and not the type */
uDataLen = WLANTOHS(pMsduEthHeader->type);
} /* while end */
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ConvertAmsduToEthPackets(): A-MSDU Packe conversion done.\n");
/* free the A-MSDU packet */
RxBufFree(pRxData->hOs, pBuffer);
return TI_OK;
}
/****************************************************************************************
* rxData_ReceivePacket *
****************************************************************************************
DESCRIPTION: receive packet CB from RxXfer.
parse the status and other parameters and forward the frame to
rxData_receivePacketFromWlan()
INPUT: Rx frame with its parameters
OUTPUT:
RETURN:
************************************************************************/
static void rxData_ReceivePacket (TI_HANDLE hRxData,
void *pBuffer)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ReceivePacket: Received BUF %x\n", pBuffer);
if (pBuffer)
{
RxIfDescriptor_t *pRxParams = (RxIfDescriptor_t*)pBuffer;
TRxAttr RxAttr;
ERate appRate;
dot11_header_t *pHdr;
/*
* First thing we do is getting the dot11_header, and than we check the status, since the header is
* needed for RX_MIC_FAILURE_ERROR
*/
pHdr = (dot11_header_t *)RX_BUF_DATA(pBuffer);
/* Check status */
switch (pRxParams->status & RX_DESC_STATUS_MASK)
{
case RX_DESC_STATUS_SUCCESS:
break;
case RX_DESC_STATUS_DECRYPT_FAIL:
{
/* This error is not important before the Connection, so we ignore it when portStatus is not OPEN */
if (pRxData->rxDataPortStatus == OPEN)
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, "rxData_ReceivePacket: Received Packet with RX_DESC_DECRYPT_FAIL\n");
}
RxBufFree(pRxData->hOs, pBuffer);
return;
}
case RX_DESC_STATUS_MIC_FAIL:
{
TI_UINT8 uKeyType;
paramInfo_t Param;
TMacAddr* pMac = &pHdr->address1; /* hold the first mac address */
/* Get BSS type */
Param.paramType = SITE_MGR_CURRENT_BSS_TYPE_PARAM;
siteMgr_getParam (pRxData->hSiteMgr, &Param);
/* For multicast/broadcast frames or in IBSS the key used is GROUP, else - it's Pairwise */
if (MAC_MULTICAST(*pMac) || Param.content.siteMgrCurrentBSSType == BSS_INDEPENDENT)
{
uKeyType = (TI_UINT8)KEY_TKIP_MIC_GROUP;
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet MIC failure. Type = Group\n");
}
/* Unicast on infrastructure */
else
{
uKeyType = (TI_UINT8)KEY_TKIP_MIC_PAIRWISE;
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet MIC failure. Type = Pairwise\n");
}
rsn_reportMicFailure (pRxData->hRsn, &uKeyType, sizeof(uKeyType));
RxBufFree(pRxData->hOs, pBuffer);
return;
}
case RX_DESC_STATUS_DRIVER_RX_Q_FAIL:
{
/* Rx queue error - free packet and return */
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet with Rx queue error \n");
RxBufFree(pRxData->hOs, pBuffer);
return;
}
default:
/* Unknown error - free packet and return */
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet with unknown status = %d\n", (pRxParams->status & RX_DESC_STATUS_MASK));
RxBufFree(pRxData->hOs, pBuffer);
return;
}
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Receive good Packet\n");
if (rate_PolicyToDrv (pRxParams->rate, &appRate) != TI_OK)
{
TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR , "rxData_ReceivePacket: can't convert hwRate=0x%x\n", pRxParams->rate);
}
/*
* Set rx attributes
*/
RxAttr.channel = pRxParams->channel;
RxAttr.packetInfo = pRxParams->flags;
RxAttr.ePacketType= pRxParams->packet_class_tag;
RxAttr.Rate = appRate;
RxAttr.Rssi = pRxParams->rx_level;
RxAttr.SNR = pRxParams->rx_snr;
RxAttr.status = pRxParams->status & RX_DESC_STATUS_MASK;
/* for now J band not implemented */
RxAttr.band = ((pRxParams->flags & RX_DESC_BAND_MASK) == RX_DESC_BAND_A) ?
RADIO_BAND_5_0_GHZ : RADIO_BAND_2_4_GHZ ;
RxAttr.eScanTag = pRxParams->proccess_id_tag;
/* timestamp is 32 bit so do bytes copy to avoid exception in case the RxInfo is in 2 bytes offset */
os_memoryCopy (pRxData->hOs,
(void *)&(RxAttr.TimeStamp),
(void *)&(pRxParams->timestamp),
sizeof(pRxParams->timestamp) );
RxAttr.TimeStamp = ENDIAN_HANDLE_LONG(RxAttr.TimeStamp);
TRACE8(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ReceivePacket: channel=%d, info=0x%x, type=%d, rate=0x%x, RSSI=%d, SNR=%d, status=%d, scan tag=%d\n", RxAttr.channel, RxAttr.packetInfo, RxAttr.ePacketType, RxAttr.Rate, RxAttr.Rssi, RxAttr.SNR, RxAttr.status, RxAttr.eScanTag);
rxData_receivePacketFromWlan (hRxData, pBuffer, &RxAttr);
/*
* Buffer MUST be freed until now
*/
}
else
{
TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR , "rxData_ReceivePacket: null Buffer received");
}
}
/****************************************************************************************
* rxData_RequestForBuffer *
****************************************************************************************
DESCRIPTION: RX request for buffer
uEncryptionflag API are for GWSI use.
INPUT:
OUTPUT:
RETURN:
************************************************************************/
static ERxBufferStatus rxData_RequestForBuffer (TI_HANDLE hRxData,
void **pBuf,
TI_UINT16 aLength,
TI_UINT32 uEncryptionflag,
PacketClassTag_e ePacketClassTag)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION , " RequestForBuffer, length = %d \n",aLength);
*pBuf = RxBufAlloc (pRxData->hOs, aLength, ePacketClassTag);
if (*pBuf)
{
return RX_BUF_ALLOC_COMPLETE;
}
else
{
return RX_BUF_ALLOC_OUT_OF_MEM;
}
}
/*******************************************************************
* DEBUG FUNCTIONS *
*******************************************************************/
#ifdef TI_DBG
/***************************************************************************
* rxData_resetCounters *
****************************************************************************
* DESCRIPTION: This function reset the Rx Data module counters
*
* INPUTS: hRxData - the object
*
* OUTPUT:
*
* RETURNS: void
***************************************************************************/
void rxData_resetCounters(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
os_memoryZero(pRxData->hOs, &pRxData->rxDataCounters, sizeof(rxDataCounters_t));
}
/***************************************************************************
* rxData_resetDbgCounters *
****************************************************************************
* DESCRIPTION: This function reset the Rx Data module debug counters
*
* INPUTS: hRxData - the object
*
* OUTPUT:
*
* RETURNS: void
***************************************************************************/
void rxData_resetDbgCounters(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
os_memoryZero(pRxData->hOs, &pRxData->rxDataDbgCounters, sizeof(rxDataDbgCounters_t));
}
/***************************************************************************
* test functions *
***************************************************************************/
void rxData_printRxCounters (TI_HANDLE hRxData)
{
#ifdef REPORT_LOG
rxData_t *pRxData = (rxData_t *)hRxData;
if (pRxData)
{
WLAN_OS_REPORT(("RecvOk = %d\n", pRxData->rxDataCounters.RecvOk));
WLAN_OS_REPORT(("DirectedBytesRecv = %d\n", pRxData->rxDataCounters.DirectedBytesRecv));
WLAN_OS_REPORT(("DirectedFramesRecv = %d\n", pRxData->rxDataCounters.DirectedFramesRecv));
WLAN_OS_REPORT(("MulticastBytesRecv = %d\n", pRxData->rxDataCounters.MulticastBytesRecv));
WLAN_OS_REPORT(("MulticastFramesRecv = %d\n", pRxData->rxDataCounters.MulticastFramesRecv));
WLAN_OS_REPORT(("BroadcastBytesRecv = %d\n", pRxData->rxDataCounters.BroadcastBytesRecv));
WLAN_OS_REPORT(("BroadcastFramesRecv = %d\n", pRxData->rxDataCounters.BroadcastFramesRecv));
/* debug counters */
WLAN_OS_REPORT(("excludedFrameCounter = %d\n", pRxData->rxDataDbgCounters.excludedFrameCounter));
WLAN_OS_REPORT(("rxDroppedDueToVLANIncludedCnt = %d\n", pRxData->rxDataDbgCounters.rxDroppedDueToVLANIncludedCnt));
WLAN_OS_REPORT(("rxWrongBssTypeCounter = %d\n", pRxData->rxDataDbgCounters.rxWrongBssTypeCounter));
WLAN_OS_REPORT(("rxWrongBssIdCounter = %d\n", pRxData->rxDataDbgCounters.rxWrongBssIdCounter));
WLAN_OS_REPORT(("rcvUnicastFrameInOpenNotify = %d\n", pRxData->rxDataDbgCounters.rcvUnicastFrameInOpenNotify));
}
#endif
}
void rxData_printRxBlock(TI_HANDLE hRxData)
{
#ifdef REPORT_LOG
rxData_t *pRxData = (rxData_t *)hRxData;
WLAN_OS_REPORT(("hCtrlData = 0x%X\n", pRxData->hCtrlData));
WLAN_OS_REPORT(("hMlme = 0x%X\n", pRxData->hMlme));
WLAN_OS_REPORT(("hOs = 0x%X\n", pRxData->hOs));
WLAN_OS_REPORT(("hReport = 0x%X\n", pRxData->hReport));
WLAN_OS_REPORT(("hRsn = 0x%X\n", pRxData->hRsn));
WLAN_OS_REPORT(("hSiteMgr = 0x%X\n", pRxData->hSiteMgr));
WLAN_OS_REPORT(("hCtrlData = 0x%X\n", pRxData->hCtrlData));
WLAN_OS_REPORT(("hMlme = 0x%X\n", pRxData->hMlme));
WLAN_OS_REPORT(("hOs = 0x%X\n", pRxData->hOs));
WLAN_OS_REPORT(("hReport = 0x%X\n", pRxData->hReport));
WLAN_OS_REPORT(("hRsn = 0x%X\n", pRxData->hRsn));
WLAN_OS_REPORT(("hSiteMgr = 0x%X\n", pRxData->hSiteMgr));
WLAN_OS_REPORT(("rxDataPortStatus = %d\n", pRxData->rxDataPortStatus));
WLAN_OS_REPORT(("rxDataExcludeUnencrypted = %d\n", pRxData->rxDataExcludeUnencrypted));
WLAN_OS_REPORT(("rxDataEapolDestination = %d\n", pRxData->rxDataEapolDestination));
#endif
}
void rxData_startRxThroughputTimer (TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
if (!pRxData->rxThroughputTimerEnable)
{
/* reset throughput counter */
pRxData->rxDataCounters.LastSecBytesRecv = 0;
pRxData->rxThroughputTimerEnable = TI_TRUE;
/* start 1 sec throughput timer */
tmr_StartTimer (pRxData->hThroughputTimer,
rxData_printRxThroughput,
(TI_HANDLE)pRxData,
1000,
TI_TRUE);
}
}
void rxData_stopRxThroughputTimer (TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
if (pRxData->rxThroughputTimerEnable)
{
tmr_StopTimer (pRxData->hThroughputTimer);
pRxData->rxThroughputTimerEnable = TI_FALSE;
}
}
static void rxData_printRxThroughput (TI_HANDLE hRxData, TI_BOOL bTwdInitOccured)
{
rxData_t *pRxData = (rxData_t *)hRxData;
WLAN_OS_REPORT (("\n"));
WLAN_OS_REPORT (("-------------- Rx Throughput Statistics ---------------\n"));
WLAN_OS_REPORT (("Throughput = %d KBits/sec\n", pRxData->rxDataCounters.LastSecBytesRecv * 8 / 1024));
/* reset throughput counter */
pRxData->rxDataCounters.LastSecBytesRecv = 0;
}
void rxData_printRxDataFilter (TI_HANDLE hRxData)
{
TI_UINT32 index;
rxData_t *pRxData = (rxData_t *)hRxData;
for (index=0; index<MAX_DATA_FILTERS; index++)
{
if (pRxData->isFilterSet[index])
{
WLAN_OS_REPORT (("index=%d, pattern & mask\n", index));
report_PrintDump(pRxData->filterRequests[index].pattern, pRxData->filterRequests[index].patternLength);
report_PrintDump(pRxData->filterRequests[index].mask, pRxData->filterRequests[index].maskLength);
}
else
{
WLAN_OS_REPORT (("No Filter defined for index-%d\n", index));
}
}
}
#endif /*TI_DBG*/
/****************************************************************************
* rxData_SetReAuthInProgress()
****************************************************************************
* DESCRIPTION: Sets the ReAuth flag value
*
* INPUTS: hRxData - the object
* value - value to set the flag to
*
* OUTPUT: None
*
* RETURNS: OK or NOK
****************************************************************************/
void rxData_SetReAuthInProgress(TI_HANDLE hRxData, TI_BOOL value)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Set ReAuth flag to %d\n", value);
pRxData->reAuthInProgress = value;
}
/****************************************************************************
* rxData_IsReAuthInProgress()
****************************************************************************
* DESCRIPTION: Returns the ReAuth flag value
*
* INPUTS: hRxData - the object
*
* OUTPUT: None
*
* RETURNS: ReAuth flag value
****************************************************************************/
TI_BOOL rxData_IsReAuthInProgress(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
return pRxData->reAuthInProgress;
}
/****************************************************************************
* rxData_StartReAuthActiveTimer *
*****************************************************************************
* DESCRIPTION: this function starts the ReAuthActive timer
*
* INPUTS: hRxData - the object
*
* OUTPUT: None
*
* RETURNS: None
***************************************************************************/
static void rxData_StartReAuthActiveTimer(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Start ReAuth Active Timer\n");
tmr_StartTimer (pRxData->reAuthActiveTimer,
reAuthTimeout,
(TI_HANDLE)pRxData,
pRxData->reAuthActiveTimeout,
TI_FALSE);
}
/****************************************************************************
* rxData_StopReAuthActiveTimer *
*****************************************************************************
* DESCRIPTION: this function stops the ReAuthActive timer
*
* INPUTS: hRxData - the object
*
* OUTPUT: None
*
* RETURNS: None
***************************************************************************/
void rxData_StopReAuthActiveTimer(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Stop ReAuth Active Timer\n");
tmr_StopTimer (pRxData->reAuthActiveTimer);
}
/****************************************************************************
* reAuthTimeout *
*****************************************************************************
* DESCRIPTION: this function ia called when the ReAuthActive timer elapses
* It resets the Reauth flag and restore the PS state.
* It also sends RE_AUTH_TERMINATED event to upper layer.
*
* INPUTS: hRxData - the object
*
* OUTPUT: None
*
* RETURNS: None
***************************************************************************/
static void reAuthTimeout(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured)
{
rxData_t *pRxData = (rxData_t *)hRxData;
TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "ReAuth Active Timeout\n");
rxData_SetReAuthInProgress(pRxData, TI_FALSE);
rxData_ReauthDisablePriority(pRxData);
EvHandlerSendEvent(pRxData->hEvHandler, IPC_EVENT_RE_AUTH_TERMINATED, NULL, 0);
}
void rxData_ReauthEnablePriority(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
paramInfo_t param;
param.paramType = POWER_MGR_ENABLE_PRIORITY;
param.content.powerMngPriority = POWER_MANAGER_REAUTH_PRIORITY;
powerMgr_setParam(pRxData->hPowerMgr,&param);
}
void rxData_ReauthDisablePriority(TI_HANDLE hRxData)
{
rxData_t *pRxData = (rxData_t *)hRxData;
paramInfo_t param;
param.paramType = POWER_MGR_DISABLE_PRIORITY;
param.content.powerMngPriority = POWER_MANAGER_REAUTH_PRIORITY;
powerMgr_setParam(pRxData->hPowerMgr,&param);
}