| /* |
| * rx.c |
| * |
| * Copyright(c) 1998 - 2010 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; |
| pRxData->genericEthertype = EAPOL_PACKET; |
| |
| /* |
| * 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); |
| } |
| |
| case RX_DATA_GENERIC_ETHERTYPE_PARAM: |
| pRxData->genericEthertype = pParamInfo->content.rxGenericEthertype; |
| break; |
| |
| 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; |
| os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, (TI_UINT8 *)&fieldPattern->offset, sizeof(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_ERROR, " 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_INFORMATION, " 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, ðerType); |
| |
| 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) || |
| (HTOWLANS(pEthernetHeader->type) == pRxData->genericEthertype)) |
| { |
| 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_ERROR, " 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, (struct RxIfDescriptor_t*)pBuffer, 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"); |
| |
| /* 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, (struct RxIfDescriptor_t*)pBuffer, 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; |
| |
| /* 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; |
| |
| /* Clear the EndOfBurst flag for all packets except the last one */ |
| ((RxIfDescriptor_t *)pDataBuf)->driverFlags &= ~DRV_RX_FLAG_END_OF_BURST; |
| } |
| else |
| { |
| /* no more MSDU */ |
| uAmsduDataLen = 0; |
| } |
| |
| |
| /* in A-MSDU the MSDU header type contain the MSDU length and not the type */ |
| uDataLen = WLANTOHS(pMsduEthHeader->type); |
| |
| |
| /* dispatch Buffer according to packet type and current rx data port status */ |
| pRxData->rxData_dispatchBuffer[pRxData->rxDataPortStatus][DataPacketType] (hRxData, pDataBuf, pRxAttr); |
| |
| } /* 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 ((ETxRateClassId)(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 = (EScanResultTag)(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,¶m); |
| } |
| |
| 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,¶m); |
| } |
