hardware/ti/wlan/wl1271/stad/src/Data_link/rx.c

   1 /*
   2  * rx.c
   3  *
   4  * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  *  * Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *  * Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *  * Neither the name Texas Instruments nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /***************************************************************************/
  35 /*                                                                         */
  36 /*      MODULE: Rx.c                                                       */
  37 /*    PURPOSE:  Rx module functions                                        */
  38 /*                                                                         */
  39 /***************************************************************************/
  40 #define __FILE_ID__  FILE_ID_54
  41 #include "tidef.h"
  42 #include "paramOut.h"
  43 #include "rx.h"
  44 #include "osApi.h"
  45 #include "timer.h"
  46 #include "DataCtrl_Api.h"
  47 #include "Ctrl.h"
  48 #include "802_11Defs.h"
  49 #include "Ethernet.h"
  50 #include "report.h"
  51 #include "rate.h"
  52 #include "mlmeApi.h"
  53 #include "rsnApi.h"
  54 #include "smeApi.h"
  55 #include "siteMgrApi.h"
  56 #include "GeneralUtil.h"
  57 #include "EvHandler.h"
  58 #ifdef XCC_MODULE_INCLUDED
  59 #include "XCCMngr.h"
  60 #endif
  61 #include "TWDriver.h"
  62 #include "RxBuf.h"
  63 #include "DrvMainModules.h"
  64 #include "bmtrace_api.h"
  65 #include "PowerMgr_API.h"
  66
  67
  68 #define EAPOL_PACKET                    0x888E
  69 #define IAPP_PACKET                     0x0000
  70 #define PREAUTH_EAPOL_PACKET            0x88C7
  71
  72
  73 #define RX_DATA_FILTER_FLAG_NO_BIT_MASK         0
  74 #define RX_DATA_FILTER_FLAG_USE_BIT_MASK        1
  75 #define RX_DATA_FILTER_FLAG_IP_HEADER           0
  76 #define RX_DATA_FILTER_FLAG_ETHERNET_HEADER     2
  77 #define RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY 14
  78
  79 #define PADDING_ETH_PACKET_SIZE                 2
  80
  81 /* CallBack for recieving packet from rxXfer */
  82 static void rxData_ReceivePacket (TI_HANDLE   hRxData,  void  *pBuffer);
  83
  84 static ERxBufferStatus rxData_RequestForBuffer (TI_HANDLE   hRxData, void **pBuf, TI_UINT16 aLength, TI_UINT32 uEncryptionFlag,PacketClassTag_e ePacketClassTag);
  85
  86 #if 0
  87 static TI_STATUS rxData_checkBssIdAndBssType(TI_HANDLE hRxData,
  88                                                                                          dot11_header_t* dot11_header,
  89                                                                                          TMacAddr **rxBssid,
  90                                                                                          ScanBssType_e  *currBssType,
  91                                                                                          TMacAddr  *currBssId);
  92 #endif
  93 static TI_STATUS rxData_convertWlanToEthHeader (TI_HANDLE hRxData, void *pBuffer, TI_UINT16 * etherType);
  94 static TI_STATUS rxData_ConvertAmsduToEthPackets (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
  95 static void rxData_dataPacketDisptcher (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
  96 static void rxData_discardPacket (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
  97 static void rxData_discardPacketVlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
  98 static void rxData_rcvPacketInOpenNotify (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
  99 static void rxData_rcvPacketEapol (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
 100 static void rxData_rcvPacketData (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
 101
 102 static TI_STATUS rxData_enableDisableRxDataFilters(TI_HANDLE hRxData, TI_BOOL enabled);
 103 static TI_STATUS rxData_addRxDataFilter(TI_HANDLE hRxData, TRxDataFilterRequest* request);
 104 static TI_STATUS rxData_removeRxDataFilter(TI_HANDLE hRxData, TRxDataFilterRequest* request);
 105
 106
 107 #ifdef XCC_MODULE_INCLUDED
 108 static void rxData_rcvPacketIapp(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr);
 109 #endif
 110 #ifdef TI_DBG
 111 static void rxData_printRxThroughput(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured);
 112 #endif
 113
 114 static void rxData_StartReAuthActiveTimer(TI_HANDLE hRxData);
 115 static void reAuthTimeout(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured);
 116 static void rxData_ReauthEnablePriority(TI_HANDLE hRxData);
 117
 118
 119 /*************************************************************************
 120 *                        rxData_create                                   *
 121 **************************************************************************
 122 * DESCRIPTION:  This function initializes the Rx data module.
 123 *
 124 * INPUT:        hOs - handle to Os Abstraction Layer
 125 *
 126 * OUTPUT:
 127 *
 128 * RETURN:       Handle to the allocated Rx data control block
 129 ************************************************************************/
 130 TI_HANDLE rxData_create (TI_HANDLE hOs)
 131 {
 132     rxData_t *pRxData;
 133
 134     /* check parameters validity */
 135     if (hOs == NULL)
 136     {
 137         WLAN_OS_REPORT(("FATAL ERROR: rxData_create(): OS handle Error - Aborting\n"));
 138         return NULL;
 139     }
 140
 141
 142     /* alocate Rx module control block */
 143     pRxData = os_memoryAlloc(hOs, (sizeof(rxData_t)));
 144
 145     if (!pRxData)
 146     {
 147         WLAN_OS_REPORT(("FATAL ERROR: rxData_create(): Error Creating Rx Module - Aborting\n"));
 148         return NULL;
 149     }
 150
 151     /* reset Rx control block */
 152     os_memoryZero (hOs, pRxData, (sizeof(rxData_t)));
 153
 154     pRxData->RxEventDistributor = DistributorMgr_Create (hOs, MAX_RX_NOTIF_REQ_ELMENTS);
 155
 156     pRxData->hOs = hOs;
 157
 158     return (TI_HANDLE)pRxData;
 159 }
 160
 161 /***************************************************************************
 162 *                           rxData_config                                  *
 163 ****************************************************************************
 164 * DESCRIPTION:  This function configures the Rx Data module
 165 *
 166 * INPUTS:       pStadHandles  - The driver modules handles
 167 *
 168 * OUTPUT:
 169 *
 170 * RETURNS:      void
 171 ***************************************************************************/
 172 void rxData_init (TStadHandlesList *pStadHandles)
 173 {
 174     rxData_t *pRxData = (rxData_t *)(pStadHandles->hRxData);
 175
 176     pRxData->hCtrlData  = pStadHandles->hCtrlData;
 177     pRxData->hTWD       = pStadHandles->hTWD;
 178     pRxData->hMlme      = pStadHandles->hMlmeSm;
 179     pRxData->hRsn       = pStadHandles->hRsn;
 180     pRxData->hSiteMgr   = pStadHandles->hSiteMgr;
 181     pRxData->hOs        = pStadHandles->hOs;
 182     pRxData->hReport    = pStadHandles->hReport;
 183     pRxData->hXCCMgr    = pStadHandles->hXCCMngr;
 184     pRxData->hEvHandler = pStadHandles->hEvHandler;
 185     pRxData->hTimer     = pStadHandles->hTimer;
 186     pRxData->hPowerMgr  = pStadHandles->hPowerMgr;
 187
 188     pRxData->rxDataExcludeUnencrypted = DEF_EXCLUDE_UNENCYPTED;
 189     pRxData->rxDataExludeBroadcastUnencrypted = DEF_EXCLUDE_UNENCYPTED;
 190     pRxData->rxDataEapolDestination = DEF_EAPOL_DESTINATION;
 191     pRxData->rxDataPortStatus = DEF_RX_PORT_STATUS;
 192         pRxData->genericEthertype = EAPOL_PACKET;
 193
 194     /*
 195      * configure rx data dispatcher
 196      */
 197
 198     /* port status close */
 199     pRxData->rxData_dispatchBuffer[CLOSE][DATA_DATA_PACKET]  = &rxData_discardPacket;       /* data  */
 200     pRxData->rxData_dispatchBuffer[CLOSE][DATA_EAPOL_PACKET] = &rxData_discardPacket;       /* eapol */
 201     pRxData->rxData_dispatchBuffer[CLOSE][DATA_IAPP_PACKET]  = &rxData_discardPacket;       /* Iapp  */
 202     pRxData->rxData_dispatchBuffer[CLOSE][DATA_VLAN_PACKET]  = &rxData_discardPacketVlan;   /* VLAN  */
 203
 204     /* port status open notify */
 205     pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_DATA_PACKET]  = &rxData_rcvPacketInOpenNotify; /* data  */
 206     pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_EAPOL_PACKET] = &rxData_rcvPacketInOpenNotify; /* eapol */
 207     pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_IAPP_PACKET]  = &rxData_rcvPacketInOpenNotify; /* Iapp  */
 208     pRxData->rxData_dispatchBuffer[OPEN_NOTIFY][DATA_VLAN_PACKET]  = &rxData_discardPacketVlan;     /* VLAN  */
 209
 210     /* port status open eapol */
 211     pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_DATA_PACKET]  = &rxData_discardPacket;      /* data  */
 212     pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_EAPOL_PACKET] = &rxData_rcvPacketEapol;     /* eapol */
 213     pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_IAPP_PACKET]  = &rxData_discardPacket;      /* Iapp  */
 214     pRxData->rxData_dispatchBuffer[OPEN_EAPOL][DATA_VLAN_PACKET]  = &rxData_discardPacketVlan;  /* VLAN  */
 215
 216     /* port status open */
 217     pRxData->rxData_dispatchBuffer[OPEN][DATA_DATA_PACKET]  = &rxData_rcvPacketData;    /* data  */
 218     pRxData->rxData_dispatchBuffer[OPEN][DATA_EAPOL_PACKET] = &rxData_rcvPacketEapol;   /* eapol */
 219 #ifdef XCC_MODULE_INCLUDED
 220     pRxData->rxData_dispatchBuffer[OPEN][DATA_IAPP_PACKET]  = &rxData_rcvPacketIapp;    /* Iapp  */
 221 #else
 222     pRxData->rxData_dispatchBuffer[OPEN][DATA_IAPP_PACKET]  = &rxData_rcvPacketData;    /* Iapp  */
 223 #endif
 224     pRxData->rxData_dispatchBuffer[OPEN][DATA_VLAN_PACKET]  = &rxData_discardPacketVlan;/* VLAN  */
 225
 226     /* register CB's for request buffer and receive CB to the lower layers */
 227     TWD_RegisterCb (pRxData->hTWD,
 228                     TWD_EVENT_RX_RECEIVE_PACKET,
 229                     (void *)rxData_ReceivePacket,
 230                     pStadHandles->hRxData);
 231
 232     TWD_RegisterCb (pRxData->hTWD,
 233                     TWD_EVENT_RX_REQUEST_FOR_BUFFER,
 234                     (void*)rxData_RequestForBuffer,
 235                     pStadHandles->hRxData);
 236 }
 237
 238
 239 TI_STATUS rxData_SetDefaults (TI_HANDLE hRxData, rxDataInitParams_t * rxDataInitParams)
 240 {
 241     rxData_t *pRxData = (rxData_t *)hRxData;
 242     int i;
 243
 244     /* init rx data filters */
 245     pRxData->filteringEnabled = rxDataInitParams->rxDataFiltersEnabled;
 246     pRxData->filteringDefaultAction = rxDataInitParams->rxDataFiltersDefaultAction;
 247     TWD_CfgEnableRxDataFilter (pRxData->hTWD, pRxData->filteringEnabled, pRxData->filteringDefaultAction);
 248
 249     for (i = 0; i < MAX_DATA_FILTERS; ++i)
 250     {
 251         if (rxDataInitParams->rxDataFilterRequests[i].maskLength > 0)
 252         {
 253             if (rxData_addRxDataFilter(hRxData, &rxDataInitParams->rxDataFilterRequests[i]) != TI_OK)
 254             {
 255                 TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid Rx Data Filter configured at init stage (at index %d)!\n", i);
 256             }
 257         }
 258     }
 259
 260         pRxData->reAuthActiveTimer = tmr_CreateTimer (pRxData->hTimer);
 261         if (pRxData->reAuthActiveTimer == NULL)
 262         {
 263         WLAN_OS_REPORT(("rxData_SetDefaults(): Failed to create reAuthActiveTimer!\n"));
 264                 return TI_NOK;
 265         }
 266
 267     pRxData->reAuthActiveTimeout = rxDataInitParams->reAuthActiveTimeout;
 268
 269         rxData_SetReAuthInProgress(pRxData, TI_FALSE);
 270
 271 #ifdef TI_DBG
 272     /* reset counters */
 273     rxData_resetCounters(pRxData);
 274     rxData_resetDbgCounters(pRxData);
 275
 276     /* allocate timer for debug throughput */
 277     pRxData->hThroughputTimer = tmr_CreateTimer (pRxData->hTimer);
 278     if (pRxData->hThroughputTimer == NULL)
 279     {
 280         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_SetDefaults(): Failed to create hThroughputTimer!\n");
 281         return TI_NOK;
 282     }
 283     pRxData->rxThroughputTimerEnable = TI_FALSE;
 284 #endif
 285
 286
 287     TRACE0(pRxData->hReport, REPORT_SEVERITY_INIT, ".....Rx Data configured successfully\n");
 288
 289     return TI_OK;
 290 }
 291
 292 /***************************************************************************
 293 *                           rxData_unLoad                                  *
 294 ****************************************************************************
 295 * DESCRIPTION:  This function unload the Rx data module.
 296 *
 297 * INPUTS:       hRxData - the object
 298 *
 299 * OUTPUT:
 300 *
 301 * RETURNS:      TI_OK - Unload succesfull
 302 *               TI_NOK - Unload unsuccesfull
 303 ***************************************************************************/
 304 TI_STATUS rxData_unLoad(TI_HANDLE hRxData)
 305 {
 306     rxData_t *pRxData = (rxData_t *)hRxData;
 307
 308     /* check parameters validity */
 309     if (pRxData == NULL)
 310     {
 311         return TI_NOK;
 312     }
 313
 314     DistributorMgr_Destroy(pRxData->RxEventDistributor);
 315
 316 #ifdef TI_DBG
 317     /* destroy periodic rx throughput timer */
 318         if (pRxData->hThroughputTimer)
 319         {
 320                 tmr_DestroyTimer (pRxData->hThroughputTimer);
 321         }
 322   #endif
 323
 324         if (pRxData->reAuthActiveTimer)
 325         {
 326                 tmr_DestroyTimer (pRxData->reAuthActiveTimer);
 327         }
 328
 329     /* free Rx Data controll block */
 330     os_memoryFree(pRxData->hOs, pRxData, sizeof(rxData_t));
 331
 332     return TI_OK;
 333 }
 334
 335
 336 /***************************************************************************
 337 *                           rxData_stop                                    *
 338 ****************************************************************************
 339 * DESCRIPTION:  this function stop the rx data.
 340 *
 341 * INPUTS:       hRxData - the object
 342 *
 343 * OUTPUT:
 344 *
 345 * RETURNS:      TI_OK - stop succesfull
 346 *               TI_NOK - stop unsuccesfull
 347 ***************************************************************************/
 348 TI_STATUS rxData_stop (TI_HANDLE hRxData)
 349 {
 350     rxData_t *pRxData = (rxData_t *)hRxData;
 351
 352     /* check parameters validity */
 353     if (pRxData == NULL)
 354     {
 355         return TI_NOK;
 356     }
 357
 358     pRxData->rxDataExcludeUnencrypted = DEF_EXCLUDE_UNENCYPTED;
 359     pRxData->rxDataExludeBroadcastUnencrypted = DEF_EXCLUDE_UNENCYPTED;
 360     pRxData->rxDataEapolDestination = DEF_EAPOL_DESTINATION;
 361     pRxData->rxDataPortStatus = DEF_RX_PORT_STATUS;
 362
 363   #ifdef TI_DBG
 364     /* reset counters */
 365     /*rxData_resetCounters(pRxData);*/
 366     /*rxData_resetDbgCounters(pRxData);*/
 367
 368     /* stop throughput timer */
 369     if (pRxData->rxThroughputTimerEnable)
 370     {
 371         tmr_StopTimer (pRxData->hThroughputTimer);
 372         pRxData->rxThroughputTimerEnable = TI_FALSE;
 373     }
 374   #endif
 375
 376     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_stop() :  Succeeded.\n");
 377
 378     return TI_OK;
 379
 380 }
 381
 382 /***************************************************************************
 383 *                           rxData_getParam                                *
 384 ****************************************************************************
 385 * DESCRIPTION:  get a specific parameter
 386 *
 387 * INPUTS:       hRxData - the object
 388 *
 389 * OUTPUT:       pParamInfo - structure which include the value of
 390 *               the requested parameter
 391 *
 392 * RETURNS:      TI_OK
 393 *               TI_NOK
 394 ***************************************************************************/
 395 TI_STATUS rxData_getParam(TI_HANDLE hRxData, paramInfo_t *pParamInfo)
 396 {
 397     rxData_t *pRxData = (rxData_t *)hRxData;
 398
 399     /* check handle validity */
 400     if (pRxData == NULL)
 401     {
 402         return TI_NOK;
 403     }
 404
 405     switch (pParamInfo->paramType)
 406     {
 407         case RX_DATA_EXCLUDE_UNENCRYPTED_PARAM:
 408             pParamInfo->content.rxDataExcludeUnencrypted = pRxData->rxDataExcludeUnencrypted;
 409             break;
 410
 411         case RX_DATA_EAPOL_DESTINATION_PARAM:
 412             pParamInfo->content.rxDataEapolDestination = pRxData->rxDataEapolDestination;
 413             break;
 414
 415         case RX_DATA_PORT_STATUS_PARAM:
 416             pParamInfo->content.rxDataPortStatus = pRxData->rxDataPortStatus;
 417             break;
 418
 419         case RX_DATA_COUNTERS_PARAM:
 420             pParamInfo->content.siteMgrTiWlanCounters.RecvOk = pRxData->rxDataCounters.RecvOk;
 421             pParamInfo->content.siteMgrTiWlanCounters.DirectedBytesRecv = pRxData->rxDataCounters.DirectedBytesRecv;
 422             pParamInfo->content.siteMgrTiWlanCounters.DirectedFramesRecv = pRxData->rxDataCounters.DirectedFramesRecv;
 423             pParamInfo->content.siteMgrTiWlanCounters.MulticastBytesRecv = pRxData->rxDataCounters.MulticastBytesRecv;
 424             pParamInfo->content.siteMgrTiWlanCounters.MulticastFramesRecv = pRxData->rxDataCounters.MulticastFramesRecv;
 425             pParamInfo->content.siteMgrTiWlanCounters.BroadcastBytesRecv = pRxData->rxDataCounters.BroadcastBytesRecv;
 426             pParamInfo->content.siteMgrTiWlanCounters.BroadcastFramesRecv = pRxData->rxDataCounters.BroadcastFramesRecv;
 427             break;
 428
 429         case RX_DATA_GET_RX_DATA_FILTERS_STATISTICS:
 430             TWD_ItrDataFilterStatistics (pRxData->hTWD,
 431                                          pParamInfo->content.interogateCmdCBParams.fCb,
 432                                          pParamInfo->content.interogateCmdCBParams.hCb,
 433                                          pParamInfo->content.interogateCmdCBParams.pCb);
 434             break;
 435
 436         case RX_DATA_RATE_PARAM:
 437             pParamInfo->content.siteMgrCurrentRxRate = pRxData->uLastDataPktRate;
 438             break;
 439
 440         default:
 441             TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_getParam() : PARAMETER NOT SUPPORTED \n");
 442             return (PARAM_NOT_SUPPORTED);
 443     }
 444
 445     return TI_OK;
 446 }
 447
 448 /***************************************************************************
 449 *                           rxData_setParam                                *
 450 ****************************************************************************
 451 * DESCRIPTION:  set a specific parameter
 452 *
 453 * INPUTS:       hRxData - the object
 454 *               pParamInfo - structure which include the value to set for
 455 *               the requested parameter
 456 *
 457 * OUTPUT:
 458 *
 459 * RETURNS:      TI_OK
 460 *               TI_NOK
 461 ***************************************************************************/
 462 TI_STATUS rxData_setParam(TI_HANDLE hRxData, paramInfo_t *pParamInfo)
 463 {
 464     rxData_t *pRxData = (rxData_t *)hRxData;
 465
 466     /* check handle validity */
 467     if( pRxData == NULL  )
 468     {
 469         return TI_NOK;
 470     }
 471
 472     switch (pParamInfo->paramType)
 473     {
 474         case RX_DATA_EXCLUDE_UNENCRYPTED_PARAM:
 475             pRxData->rxDataExcludeUnencrypted = pParamInfo->content.rxDataExcludeUnencrypted;
 476             break;
 477         case RX_DATA_EXCLUDE_BROADCAST_UNENCRYPTED_PARAM:
 478             pRxData->rxDataExludeBroadcastUnencrypted = pParamInfo->content.rxDataExcludeUnencrypted;
 479             break;
 480         case RX_DATA_EAPOL_DESTINATION_PARAM:
 481             pRxData->rxDataEapolDestination = pParamInfo->content.rxDataEapolDestination;
 482             break;
 483
 484         case RX_DATA_PORT_STATUS_PARAM:
 485             pRxData->rxDataPortStatus = pParamInfo->content.rxDataPortStatus;
 486             break;
 487
 488         case RX_DATA_ENABLE_DISABLE_RX_DATA_FILTERS:
 489             return rxData_enableDisableRxDataFilters(hRxData, pParamInfo->content.rxDataFilterEnableDisable);
 490
 491         case RX_DATA_ADD_RX_DATA_FILTER:
 492         {
 493             TRxDataFilterRequest* pRequest = &pParamInfo->content.rxDataFilterRequest;
 494
 495             return rxData_addRxDataFilter(hRxData, pRequest);
 496         }
 497
 498         case RX_DATA_REMOVE_RX_DATA_FILTER:
 499         {
 500             TRxDataFilterRequest* pRequest = &pParamInfo->content.rxDataFilterRequest;
 501
 502             return rxData_removeRxDataFilter(hRxData, pRequest);
 503         }
 504
 505         case RX_DATA_GENERIC_ETHERTYPE_PARAM:
 506             pRxData->genericEthertype = pParamInfo->content.rxGenericEthertype;
 507             break;
 508
 509         default:
 510             TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_setParam() : PARAMETER NOT SUPPORTED \n");
 511             return (PARAM_NOT_SUPPORTED);
 512     }
 513
 514     return TI_OK;
 515 }
 516
 517 /***************************************************************************
 518 *                     rxData_enableDisableRxDataFilters                    *
 519 ****************************************************************************
 520 * DESCRIPTION:
 521 *
 522 *
 523 * INPUTS:
 524 *
 525 *
 526 *
 527 * OUTPUT:
 528 *
 529 * RETURNS:
 530 *
 531 ***************************************************************************/
 532 static TI_STATUS rxData_enableDisableRxDataFilters(TI_HANDLE hRxData, TI_BOOL enabled)
 533 {
 534     rxData_t * pRxData = (rxData_t *) hRxData;
 535
 536     /* assert 0 or 1 */
 537     if (enabled != TI_FALSE)
 538         enabled = 1;
 539
 540     if (enabled == pRxData->filteringEnabled)
 541         return TI_OK;
 542
 543     pRxData->filteringEnabled = enabled;
 544
 545     return TWD_CfgEnableRxDataFilter (pRxData->hTWD, pRxData->filteringEnabled, pRxData->filteringDefaultAction);
 546 }
 547
 548 /***************************************************************************
 549 *                          findFilterRequest                               *
 550 ****************************************************************************
 551 * DESCRIPTION:
 552 *
 553 *
 554 * INPUTS:
 555 *
 556 *
 557 *
 558 * OUTPUT:
 559 *
 560 * RETURNS:
 561 *
 562 ***************************************************************************/
 563 static int findFilterRequest(TI_HANDLE hRxData, TRxDataFilterRequest* request)
 564 {
 565     rxData_t * pRxData = (rxData_t *) hRxData;
 566     int i;
 567
 568     for (i = 0; i < MAX_DATA_FILTERS; ++i)
 569     {
 570         if (pRxData->isFilterSet[i])
 571         {
 572             if ((pRxData->filterRequests[i].offset == request->offset) &&
 573                 (pRxData->filterRequests[i].maskLength == request->maskLength) &&
 574                 (pRxData->filterRequests[i].patternLength == request->patternLength))
 575             {
 576                 if ((os_memoryCompare(pRxData->hOs, pRxData->filterRequests[i].mask, request->mask, request->maskLength) == 0) &&
 577                     (os_memoryCompare(pRxData->hOs, pRxData->filterRequests[i].pattern, request->pattern, request->patternLength) == 0))
 578                     return i;
 579             }
 580         }
 581     }
 582
 583     return -1;
 584 }
 585
 586 /***************************************************************************
 587 *                            closeFieldPattern                             *
 588 ****************************************************************************
 589 * DESCRIPTION:
 590 *
 591 *
 592 * INPUTS:
 593 *
 594 *
 595 *
 596 * OUTPUT:
 597 *
 598 * RETURNS:
 599 *
 600 ***************************************************************************/
 601 static void closeFieldPattern (rxData_t * pRxData, rxDataFilterFieldPattern_t * fieldPattern, TI_UINT8 * fieldPatterns, TI_UINT8 * lenFieldPatterns)
 602 {
 603     //fieldPatterns[*lenFieldPatterns] = fieldPattern->offset;
 604         os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, (TI_UINT8 *)&fieldPattern->offset, sizeof(fieldPattern->offset));
 605     *lenFieldPatterns += sizeof(fieldPattern->offset);
 606
 607     fieldPatterns[*lenFieldPatterns] = fieldPattern->length;
 608     *lenFieldPatterns += sizeof(fieldPattern->length);
 609
 610     fieldPatterns[*lenFieldPatterns] = fieldPattern->flag;
 611     *lenFieldPatterns += sizeof(fieldPattern->flag);
 612
 613     os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, fieldPattern->pattern, fieldPattern->length);
 614     *lenFieldPatterns += fieldPattern->length;
 615
 616     /* if the pattern bit mask is enabled add it to the end of the request */
 617     if ((fieldPattern->flag & RX_DATA_FILTER_FLAG_USE_BIT_MASK) == RX_DATA_FILTER_FLAG_USE_BIT_MASK)
 618     {
 619         os_memoryCopy(pRxData->hOs, fieldPatterns + *lenFieldPatterns, fieldPattern->mask, fieldPattern->length);
 620         *lenFieldPatterns += fieldPattern->length;
 621     }
 622
 623     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));
 624 }
 625
 626
 627 /***************************************************************************
 628 *                         parseRxDataFilterRequest                         *
 629 ****************************************************************************
 630 * DESCRIPTION:
 631 *
 632 *
 633 * INPUTS:
 634 *
 635 *
 636 *
 637 * OUTPUT:
 638 *
 639 * RETURNS:
 640 *
 641 ***************************************************************************/
 642 static int parseRxDataFilterRequest(TI_HANDLE hRxData, TRxDataFilterRequest* request, TI_UINT8 * numFieldPatterns, TI_UINT8 * lenFieldPatterns, TI_UINT8 * fieldPatterns)
 643 {
 644     rxData_t * pRxData = (rxData_t *) hRxData;
 645
 646     int maskIter;
 647     int patternIter = 0;
 648
 649     /* used to store field patterns while they are built */
 650     TI_BOOL isBuildingFieldPattern = TI_FALSE;
 651     rxDataFilterFieldPattern_t fieldPattern;
 652
 653     for (maskIter = 0; maskIter < request->maskLength * 8; ++maskIter)
 654     {
 655         /* which byte in the mask and which bit in the byte we're at */
 656         int bit = maskIter % 8;
 657         int byte = maskIter / 8;
 658
 659         /* is the bit in the mask set */
 660         TI_BOOL isSet = ((request->mask[byte] & (1 << bit)) == (1 << bit));
 661
 662         TRACE4(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": MaskIter = %d, Byte = %d, Bit = %d, isSet = %d\n", maskIter, byte, bit, isSet);
 663
 664         /* if we're in the midst of building a field pattern, we need to close in case */
 665         /* the current bit is not set or we've reached the ethernet header boundary */
 666         if (isBuildingFieldPattern)
 667         {
 668             if ((isSet == TI_FALSE) || (request->offset + maskIter == RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY))
 669             {
 670                 closeFieldPattern(hRxData, &fieldPattern, fieldPatterns, lenFieldPatterns);
 671
 672                 isBuildingFieldPattern = TI_FALSE;
 673             }
 674         }
 675
 676         /* nothing to do in case the bit is not set */
 677         if (isSet)
 678         {
 679             /* if not already building a field pattern, create a new one */
 680             if (isBuildingFieldPattern == TI_FALSE)
 681             {
 682                 TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Creating a new field pattern.\n");
 683
 684                 isBuildingFieldPattern = TI_TRUE;
 685                 ++(*numFieldPatterns);
 686
 687                 if (*numFieldPatterns > RX_DATA_FILTER_MAX_FIELD_PATTERNS)
 688                 {
 689                     TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, too many field patterns, maximum of %u is allowed!\n", RX_DATA_FILTER_MAX_FIELD_PATTERNS);
 690
 691                     return TI_NOK;
 692                 }
 693
 694                 fieldPattern.offset = request->offset + maskIter;
 695                 fieldPattern.length = 0;
 696
 697                 /* we don't support the mask per bit feature yet. */
 698                 fieldPattern.flag = RX_DATA_FILTER_FLAG_NO_BIT_MASK;
 699
 700                 /* first 14 bits are used for the Ethernet header, rest for the IP header */
 701                 if (fieldPattern.offset < RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY)
 702                 {
 703                     fieldPattern.flag |= RX_DATA_FILTER_FLAG_ETHERNET_HEADER;
 704                 }
 705                 else
 706                 {
 707                     fieldPattern.flag |= RX_DATA_FILTER_FLAG_IP_HEADER;
 708                     fieldPattern.offset -= RX_DATA_FILTER_ETHERNET_HEADER_BOUNDARY;
 709                 }
 710
 711                 TRACE2(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": offset = %d, flag = %d.\n", fieldPattern.offset, fieldPattern.flag);
 712             }
 713
 714             /* check that the pattern is long enough */
 715             if (patternIter > request->patternLength)
 716             {
 717                 TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, mask and pattern length are not consistent!\n");
 718
 719                 return TI_NOK;
 720             }
 721
 722             /* add the current pattern byte to the field pattern */
 723             fieldPattern.pattern[fieldPattern.length++] = request->pattern[patternIter++];
 724
 725             /* check pattern matching boundary */
 726             if (fieldPattern.offset + fieldPattern.length >= RX_DATA_FILTER_FILTER_BOUNDARY)
 727             {
 728                 TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, pattern matching cannot exceed first %u characters.\n", RX_DATA_FILTER_FILTER_BOUNDARY);
 729
 730                 return TI_NOK;
 731             }
 732         }
 733     }
 734
 735     /* check that the pattern is long enough */
 736     if (patternIter != request->patternLength)
 737     {
 738         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": Invalid filter, mask and pattern lengths are not consistent!\n");
 739
 740         return TI_NOK;
 741     }
 742
 743     /* close the last field pattern if needed */
 744     if (isBuildingFieldPattern)
 745     {
 746         closeFieldPattern (hRxData, &fieldPattern, fieldPatterns, lenFieldPatterns);
 747     }
 748
 749     return TI_OK;
 750 }
 751
 752
 753 /***************************************************************************
 754 *                           rxData_setRxDataFilter                         *
 755 ****************************************************************************
 756 * DESCRIPTION:
 757 *
 758 *
 759 * INPUTS:
 760 *
 761 *
 762 *
 763 * OUTPUT:
 764 *
 765 * RETURNS:
 766 *
 767 ***************************************************************************/
 768 static TI_STATUS rxData_addRxDataFilter (TI_HANDLE hRxData, TRxDataFilterRequest* request)
 769 {
 770     rxData_t * pRxData = (rxData_t *) hRxData;
 771
 772     /* firmware request fields */
 773     TI_UINT8 index = 0;
 774     TI_UINT8 numFieldPatterns = 0;
 775     TI_UINT8 lenFieldPatterns = 0;
 776     TI_UINT8 fieldPatterns[MAX_DATA_FILTER_SIZE];
 777
 778     /* does the filter already exist? */
 779     if (findFilterRequest(hRxData, request) >= 0)
 780     {
 781         TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Filter already exists.\n");
 782
 783         return RX_FILTER_ALREADY_EXISTS;
 784     }
 785
 786     /* find place for insertion */
 787     for (index = 0; index < MAX_DATA_FILTERS; ++index)
 788     {
 789         if (pRxData->isFilterSet[index] == TI_FALSE)
 790             break;
 791     }
 792
 793     /* are all filter slots taken? */
 794     if (index == MAX_DATA_FILTERS)
 795     {
 796         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, ": No place to insert filter!\n");
 797
 798         return RX_NO_AVAILABLE_FILTERS;
 799     }
 800
 801     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Inserting filter at index %d.\n", index);
 802
 803     /* parse the filter request into discrete field patterns */
 804     if (parseRxDataFilterRequest(hRxData, request, &numFieldPatterns, &lenFieldPatterns, fieldPatterns) != TI_OK)
 805         return TI_NOK;
 806
 807     if (numFieldPatterns == 0)
 808         return TI_NOK;
 809
 810     /* Store configuration for future manipulation */
 811     pRxData->isFilterSet[index] = TI_TRUE;
 812     os_memoryCopy(pRxData->hOs, &pRxData->filterRequests[index], request, sizeof(pRxData->filterRequests[index]));
 813
 814     /* Send configuration to firmware */
 815     return TWD_CfgRxDataFilter (pRxData->hTWD,
 816                                 index,
 817                                 ADD_FILTER,
 818                                 FILTER_SIGNAL,
 819                                 numFieldPatterns,
 820                                 lenFieldPatterns,
 821                                 fieldPatterns);
 822
 823 }
 824
 825 /***************************************************************************
 826 *                         rxData_removeRxDataFilter                        *
 827 ****************************************************************************
 828 * DESCRIPTION:
 829 *
 830 *
 831 * INPUTS:
 832 *
 833 *
 834 *
 835 * OUTPUT:
 836 *
 837 * RETURNS:
 838 *
 839 ***************************************************************************/
 840 static TI_STATUS rxData_removeRxDataFilter (TI_HANDLE hRxData, TRxDataFilterRequest* request)
 841 {
 842     rxData_t * pRxData = (rxData_t *) hRxData;
 843
 844     int index = findFilterRequest(hRxData, request);
 845
 846     /* does the filter exist? */
 847     if (index < 0)
 848     {
 849         TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, ": Remove data filter request received but the specified filter was not found!");
 850
 851         return RX_FILTER_DOES_NOT_EXIST;
 852     }
 853
 854     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, ": Removing filter at index %d.", index);
 855
 856     pRxData->isFilterSet[index] = TI_FALSE;
 857
 858     return TWD_CfgRxDataFilter (pRxData->hTWD,
 859                                 index,
 860                                 REMOVE_FILTER,
 861                                 FILTER_SIGNAL,
 862                                 0,
 863                                 0,
 864                                 NULL);
 865 }
 866
 867 /***************************************************************************
 868 *                       rxData_DistributorRxEvent                          *
 869 ****************************************************************************
 870 * DESCRIPTION:
 871 *
 872 *
 873 * INPUTS:
 874 *
 875 *
 876 *
 877 * OUTPUT:
 878 *
 879 * RETURNS:
 880 *
 881 ***************************************************************************/
 882 static void rxData_DistributorRxEvent (rxData_t *pRxData, TI_UINT16 Mask, int DataLen)
 883 {
 884     DistributorMgr_EventCall (pRxData->RxEventDistributor, Mask, DataLen);
 885 }
 886
 887 /***************************************************************************
 888 *                       rxData_RegNotif                                    *
 889 ****************************************************************************/
 890 TI_HANDLE rxData_RegNotif (TI_HANDLE hRxData, TI_UINT16 EventMask, GeneralEventCall_t CallBack, TI_HANDLE context, TI_UINT32 Cookie)
 891 {
 892     rxData_t *pRxData = (rxData_t *)hRxData;
 893
 894     if (!hRxData)
 895         return NULL;
 896
 897     return DistributorMgr_Reg (pRxData->RxEventDistributor, EventMask, (TI_HANDLE)CallBack, context, Cookie);
 898 }
 899
 900 /***************************************************************************
 901 *                       rxData_AddToNotifMask                              *
 902 ****************************************************************************/
 903 TI_STATUS rxData_AddToNotifMask (TI_HANDLE hRxData, TI_HANDLE Notifh, TI_UINT16 EventMask)
 904 {
 905     rxData_t *pRxData = (rxData_t *)hRxData;
 906
 907     if (!hRxData)
 908         return TI_NOK;
 909
 910     return DistributorMgr_AddToMask (pRxData->RxEventDistributor, Notifh, EventMask);
 911 }
 912
 913
 914 /***************************************************************************
 915 *                       rxData_UnRegNotif                                  *
 916 ****************************************************************************/
 917 TI_STATUS rxData_UnRegNotif(TI_HANDLE hRxData,TI_HANDLE RegEventHandle)
 918 {
 919     rxData_t *pRxData = (rxData_t *)hRxData;
 920
 921     if (!hRxData)
 922         return TI_NOK;
 923
 924     return DistributorMgr_UnReg (pRxData->RxEventDistributor, RegEventHandle);
 925 }
 926
 927
 928 /***************************************************************************
 929 *                       rxData_receivePacketFromWlan                       *
 930 ****************************************************************************
 931 * DESCRIPTION:  this function is called by the GWSI for each received Buffer.
 932 *               It filter and distribute the received Buffer.
 933 *
 934 * INPUTS:       hRxData - the object
 935 *               pBuffer - the received Buffer.
 936 *               pRxAttr - Rx attributes
 937 *
 938 * OUTPUT:
 939 *
 940 * RETURNS:
 941 ***************************************************************************/
 942 void rxData_receivePacketFromWlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
 943 {
 944     rxData_t        *pRxData    = (rxData_t *)hRxData;
 945     TMacAddr        address3;
 946     dot11_header_t  *pDot11Hdr;
 947
 948     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_receivePacketFromWlan() : pRxAttr->packetType = %d\n", pRxAttr->ePacketType);
 949
 950     switch (pRxAttr->ePacketType)
 951     {
 952     case TAG_CLASS_MANAGEMENT:
 953     case TAG_CLASS_BCN_PRBRSP:
 954
 955         TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_receivePacketFromWlan(): Received management Buffer len = %d\n", RX_BUF_LEN(pBuffer));
 956
 957         /* update siteMngr
 958          *
 959          * the BSSID in mgmt frames is always addr3 in the header
 960          * must copy address3 since Buffer is freed in mlmeParser_recv
 961          */
 962         pDot11Hdr = (dot11_header_t*)RX_BUF_DATA(pBuffer);
 963
 964         os_memoryCopy(pRxData->hOs, &address3, &pDot11Hdr->address3, sizeof(address3));
 965
 966         /* distribute mgmt pBuffer to mlme */
 967         if( mlmeParser_recv(pRxData->hMlme, pBuffer, pRxAttr) != TI_OK )
 968         {
 969             TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_receivePacketFromWlan() : MLME returned error \n");
 970         }
 971         break;
 972
 973     case TAG_CLASS_DATA:
 974     case TAG_CLASS_QOS_DATA:
 975     case TAG_CLASS_AMSDU:
 976     case TAG_CLASS_EAPOL:
 977         {
 978             CL_TRACE_START_L3();
 979             TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_receivePacketFromWlan() : Received Data Buffer len = %d\n", RX_BUF_LEN(pBuffer));
 980
 981             /* send pBuffer to data dispatcher */
 982             rxData_dataPacketDisptcher(hRxData, pBuffer, pRxAttr);
 983             CL_TRACE_END_L3("tiwlan_drv.ko", "INHERIT", "RX", ".DataPacket");
 984             break;
 985         }
 986
 987     default:
 988         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_receivePacketFromWlan(): Received unspecified packet type !!! \n");
 989         RxBufFree(pRxData->hOs, pBuffer);
 990         break;
 991     }
 992 }
 993
 994 /***************************************************************************
 995 *                       rxData_dataPacketDisptcher                         *
 996 ****************************************************************************
 997 * DESCRIPTION:  this function is called upon receving data Buffer,
 998 *               it dispatches the packet to the approciate function according to
 999 *               data packet type and rx port status.
1000 *
1001 * INPUTS:       hRxData - the object
1002 *               pBuffer - the received Buffer.
1003 *               pRxAttr - Rx attributes
1004 *
1005 * OUTPUT:
1006 *
1007 * RETURNS:
1008 ***************************************************************************/
1009
1010 static void rxData_dataPacketDisptcher (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1011 {
1012     rxData_t *pRxData = (rxData_t *)hRxData;
1013     portStatus_e DataPortStatus;
1014     rxDataPacketType_e DataPacketType;
1015
1016     /* get rx port status */
1017     DataPortStatus = pRxData->rxDataPortStatus;
1018
1019     /* discard data packets received while rx data port is closed */
1020     if (DataPortStatus == CLOSE)
1021     {
1022         TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Data Buffer while Rx data port is closed \n");
1023
1024         rxData_discardPacket (hRxData, pBuffer, pRxAttr);
1025         return;
1026     }
1027
1028     /* get data packet type */
1029
1030     pRxData->uLastDataPktRate = pRxAttr->Rate;  /* save Rx packet rate for statistics */
1031
1032 #ifdef XCC_MODULE_INCLUDED
1033     if (XCCMngr_isIappPacket (pRxData->hXCCMgr, pBuffer) == TI_TRUE)
1034     {
1035         TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Iapp Buffer  \n");
1036
1037         DataPacketType = DATA_IAPP_PACKET;
1038
1039         /* dispatch Buffer according to packet type and current rx data port status */
1040         pRxData->rxData_dispatchBuffer[DataPortStatus][DataPacketType] (hRxData, pBuffer, pRxAttr);
1041     }
1042     else
1043 #endif
1044     {
1045         /* A-MSDU ? */
1046         if (TAG_CLASS_AMSDU == pRxAttr->ePacketType)
1047         {
1048            rxData_ConvertAmsduToEthPackets (hRxData, pBuffer, pRxAttr);
1049         }
1050         else
1051         {
1052            TI_UINT16 etherType = 0;
1053            TEthernetHeader * pEthernetHeader;
1054
1055            /*
1056             * if Host processes received packets, the header translation
1057             * from WLAN to ETH is done here. The conversion has been moved
1058             * here so that IAPP packets aren't converted.
1059             */
1060            rxData_convertWlanToEthHeader (hRxData, pBuffer, &etherType);
1061
1062            pEthernetHeader = (TEthernetHeader *)RX_ETH_PKT_DATA(pBuffer);
1063
1064            if (etherType == ETHERTYPE_802_1D)
1065            {
1066                TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received VLAN packet  \n");
1067
1068                DataPacketType = DATA_VLAN_PACKET;
1069            }
1070            else if ((HTOWLANS(pEthernetHeader->type) == EAPOL_PACKET) ||
1071                                         (HTOWLANS(pEthernetHeader->type) == pRxData->genericEthertype))
1072            {
1073                                 TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Eapol packet  \n");
1074
1075                                 if (rxData_IsReAuthInProgress(pRxData))
1076                                 {
1077                                         /* ReAuth already in progress, restart timer */
1078                                         rxData_StopReAuthActiveTimer(pRxData);
1079                                         rxData_StartReAuthActiveTimer(pRxData);
1080                                 }
1081                                 else
1082                                 {
1083                                         if (PowerMgr_getReAuthActivePriority(pRxData->hPowerMgr))
1084                                         {
1085                                                 /* ReAuth not in progress yet, force active, set flag, restart timer, send event */
1086                                                 rxData_SetReAuthInProgress(pRxData, TI_TRUE);
1087                                                 rxData_StartReAuthActiveTimer(pRxData);
1088                                                 rxData_ReauthEnablePriority(pRxData);
1089                                                 EvHandlerSendEvent(pRxData->hEvHandler, IPC_EVENT_RE_AUTH_STARTED, NULL, 0);
1090                                         }
1091                                 }
1092
1093                                 DataPacketType = DATA_EAPOL_PACKET;
1094            }
1095            else
1096            {
1097                TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_dataPacketDisptcher() : Received Data packet  \n");
1098
1099                DataPacketType = DATA_DATA_PACKET;
1100            }
1101
1102            /* dispatch Buffer according to packet type and current rx data port status */
1103            pRxData->rxData_dispatchBuffer[DataPortStatus][DataPacketType] (hRxData, pBuffer, pRxAttr);
1104         }
1105     }
1106
1107 }
1108
1109 /***************************************************************************
1110 *                       rxData_discardPacket                                   *
1111 ****************************************************************************
1112 * DESCRIPTION:  this function is called to discard Buffer
1113 *
1114 * INPUTS:       hRxData - the object
1115 *               pBuffer - the received Buffer.
1116 *               pRxAttr - Rx attributes
1117 *
1118 * OUTPUT:
1119 *
1120 * RETURNS:
1121 ***************************************************************************/
1122 static void rxData_discardPacket (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1123 {
1124     rxData_t *pRxData = (rxData_t *)hRxData;
1125
1126     TRACE2(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_discardPacket: rx port status = %d , Buffer status = %d  \n", pRxData->rxDataPortStatus, pRxAttr->status);
1127
1128     pRxData->rxDataDbgCounters.excludedFrameCounter++;
1129
1130     /* free Buffer */
1131     RxBufFree(pRxData->hOs, pBuffer);
1132
1133 }
1134
1135 /***************************************************************************
1136 *                       rxData_discardPacketVlan                                   *
1137 ****************************************************************************
1138 * DESCRIPTION:  this function is called to discard Buffer
1139 *
1140 * INPUTS:       hRxData - the object
1141 *               pBuffer - the received Buffer.
1142 *               pRxAttr - Rx attributes
1143 *
1144 * OUTPUT:
1145 *
1146 * RETURNS:
1147 ***************************************************************************/
1148 static void rxData_discardPacketVlan (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1149 {
1150     rxData_t *pRxData = (rxData_t *)hRxData;
1151
1152     TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_discardPacketVlan : drop packet that contains VLAN tag\n");
1153
1154     pRxData->rxDataDbgCounters.rxDroppedDueToVLANIncludedCnt++;
1155
1156     /* free Buffer */
1157     RxBufFree(pRxData->hOs, pBuffer);
1158 }
1159
1160
1161 /***************************************************************************
1162 *                       rxData_rcvPacketInOpenNotify                         *
1163 ****************************************************************************
1164 * DESCRIPTION:  this function is called upon receving data Eapol packet type
1165 *               while rx port status is "open notify"
1166 *
1167 * INPUTS:       hRxData - the object
1168 *               pBuffer - the received Buffer.
1169 *               pRxAttr - Rx attributes
1170 *
1171 * OUTPUT:
1172 *
1173 * RETURNS:
1174 ***************************************************************************/
1175 static void rxData_rcvPacketInOpenNotify (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1176 {
1177     rxData_t *pRxData = (rxData_t *)hRxData;
1178
1179     TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, " rxData_rcvPacketInOpenNotify: receiving data packet while in rx port status is open notify\n");
1180
1181     pRxData->rxDataDbgCounters.rcvUnicastFrameInOpenNotify++;
1182
1183     /* free Buffer */
1184     RxBufFree(pRxData->hOs, pBuffer);
1185 }
1186
1187
1188 /***************************************************************************
1189 *                       rxData_rcvPacketEapol                               *
1190 ****************************************************************************
1191 * DESCRIPTION:  this function is called upon receving data Eapol packet type
1192 *               while rx port status is "open  eapol"
1193 *
1194 * INPUTS:       hRxData - the object
1195 *               pBuffer - the received Buffer.
1196 *               pRxAttr - Rx attributes
1197 *
1198 * OUTPUT:
1199 *
1200 * RETURNS:
1201 ***************************************************************************/
1202 static void rxData_rcvPacketEapol(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1203 {
1204     rxData_t *pRxData = (rxData_t *)hRxData;
1205
1206     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketEapol() : Received an EAPOL frame tranferred to OS\n");
1207
1208     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketEapol() : Received an EAPOL frame tranferred to OS\n");
1209
1210     EvHandlerSendEvent (pRxData->hEvHandler, IPC_EVENT_EAPOL, NULL, 0);
1211     os_receivePacket (pRxData->hOs, (struct RxIfDescriptor_t*)pBuffer, pBuffer, (TI_UINT16)RX_ETH_PKT_LEN(pBuffer));
1212
1213 }
1214
1215 /***************************************************************************
1216 *                       rxData_rcvPacketData                                 *
1217 ****************************************************************************
1218 * DESCRIPTION:  this function is called upon receving data "data" packet type
1219 *               while rx port status is "open"
1220 *
1221 * INPUTS:       hRxData - the object
1222 *               pBuffer - the received Buffer.
1223 *               pRxAttr - Rx attributes
1224 *
1225 * OUTPUT:
1226 *
1227 * RETURNS:
1228 ***************************************************************************/
1229 static void rxData_rcvPacketData(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1230 {
1231     rxData_t *pRxData = (rxData_t *)hRxData;
1232     TEthernetHeader *pEthernetHeader;
1233     TI_UINT16 EventMask = 0;
1234     TFwInfo *pFwInfo;
1235
1236     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketData() : Received DATA frame tranferred to OS\n");
1237
1238     /* check encryption status */
1239     pEthernetHeader = (TEthernetHeader *)RX_ETH_PKT_DATA(pBuffer);
1240     if (!MAC_MULTICAST (pEthernetHeader->dst))
1241     {  /* unicast frame */
1242         if((pRxData->rxDataExcludeUnencrypted) && (!(pRxAttr->packetInfo & RX_DESC_ENCRYPT_MASK)))
1243         {
1244             pRxData->rxDataDbgCounters.excludedFrameCounter++;
1245             /* free Buffer */
1246             TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_rcvPacketData() : exclude unicast unencrypted is TI_TRUE & packet encryption is OFF\n");
1247
1248             RxBufFree(pRxData->hOs, pBuffer);
1249             return;
1250         }
1251     }
1252     else
1253     {  /* broadcast frame */
1254         if ((pRxData->rxDataExludeBroadcastUnencrypted) && (!(pRxAttr->packetInfo & RX_DESC_ENCRYPT_MASK)))
1255         {
1256             pRxData->rxDataDbgCounters.excludedFrameCounter++;
1257             /* free Buffer */
1258             TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, " rxData_rcvPacketData() : exclude broadcast unencrypted is TI_TRUE & packet encryption is OFF\n");
1259
1260             RxBufFree(pRxData->hOs, pBuffer);
1261             return;
1262         }
1263
1264         /*
1265          * Discard multicast/broadcast frames that we sent ourselves.
1266          * Per IEEE 802.11-2007 section 9.2.7: "STAs shall filter out
1267          * broadcast/multicast messages that contain their address as
1268          * the source address."
1269          */
1270         pFwInfo = TWD_GetFWInfo (pRxData->hTWD);
1271         if (MAC_EQUAL(pFwInfo->macAddress, pEthernetHeader->src))
1272         {
1273             pRxData->rxDataDbgCounters.excludedFrameCounter++;
1274             /* free Buffer */
1275             RxBufFree(pRxData->hOs, pBuffer);
1276             return;
1277         }
1278     }
1279
1280     /* update traffic monitor parameters */
1281     pRxData->rxDataCounters.RecvOk++;
1282     EventMask |= RECV_OK;
1283
1284     if (!MAC_MULTICAST (pEthernetHeader->dst))
1285     {
1286         /* Directed frame */
1287         pRxData->rxDataCounters.DirectedFramesRecv++;
1288         pRxData->rxDataCounters.DirectedBytesRecv += RX_ETH_PKT_LEN(pBuffer);
1289         EventMask |= DIRECTED_BYTES_RECV;
1290         EventMask |= DIRECTED_FRAMES_RECV;
1291     }
1292     else if (MAC_BROADCAST (pEthernetHeader->dst))
1293     {
1294         /* Broadcast frame */
1295         pRxData->rxDataCounters.BroadcastFramesRecv++;
1296         pRxData->rxDataCounters.BroadcastBytesRecv += RX_ETH_PKT_LEN(pBuffer);
1297         EventMask |= BROADCAST_BYTES_RECV;
1298         EventMask |= BROADCAST_FRAMES_RECV;
1299     }
1300     else
1301     {
1302         /* Multicast Address */
1303         pRxData->rxDataCounters.MulticastFramesRecv++;
1304         pRxData->rxDataCounters.MulticastBytesRecv += RX_ETH_PKT_LEN(pBuffer);
1305         EventMask |= MULTICAST_BYTES_RECV;
1306         EventMask |= MULTICAST_FRAMES_RECV;
1307     }
1308     pRxData->rxDataCounters.LastSecBytesRecv += RX_ETH_PKT_LEN(pBuffer);
1309
1310     /*Handle PREAUTH_EAPOL_PACKET*/
1311     if (HTOWLANS(pEthernetHeader->type) == PREAUTH_EAPOL_PACKET)
1312     {
1313         TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketData() : Received an Pre-Auth EAPOL frame tranferred to OS\n");
1314     }
1315
1316     rxData_DistributorRxEvent (pRxData, EventMask, RX_ETH_PKT_LEN(pBuffer));
1317
1318     /* deliver packet to os */
1319     os_receivePacket (pRxData->hOs, (struct RxIfDescriptor_t*)pBuffer, pBuffer, (TI_UINT16)RX_ETH_PKT_LEN(pBuffer));
1320 }
1321
1322
1323 /***************************************************************************
1324 *                       rxData_rcvPacketIapp                                 *
1325 ****************************************************************************
1326 * DESCRIPTION:  this function is called upon receving data IAPP packet type
1327 *               while rx port status is "open"
1328 *
1329 * INPUTS:       hRxData - the object
1330 *               pBuffer - the received Buffer.
1331 *               pRxAttr - Rx attributes
1332 *
1333 * OUTPUT:
1334 *
1335 * RETURNS:
1336 ***************************************************************************/
1337 #ifdef XCC_MODULE_INCLUDED
1338
1339 static void rxData_rcvPacketIapp(TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1340 {
1341     rxData_t *pRxData = (rxData_t *)hRxData;
1342
1343     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketIapp() : Received IAPP frame tranferred to XCCMgr\n");
1344
1345     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_rcvPacketIapp() : Received IAPP frame tranferred to XCCMgr\n");
1346
1347     /* tranfer packet to XCCMgr */
1348     XCCMngr_recvIAPPPacket (pRxData->hXCCMgr, pBuffer, pRxAttr);
1349
1350     /* free Buffer */
1351     RxBufFree(pRxData->hOs, pBuffer);
1352 }
1353
1354 #endif
1355
1356
1357 /****************************************************************************
1358 *                       rxData_convertWlanToEthHeader                       *
1359 *****************************************************************************
1360 * DESCRIPTION:  this function convert the Packet header from 802.11 header
1361 *               format to ethernet format
1362 *
1363 * INPUTS:       hRxData - the object
1364 *               pBuffer - the received pBuffer in 802.11 format
1365 *
1366 * OUTPUT:       pEthPacket  - pointer to the received pBuffer in ethernet format
1367 *               uEthLength - ethernet packet length
1368 *
1369 * RETURNS:      TI_OK/TI_NOK
1370 ***************************************************************************/
1371 static TI_STATUS rxData_convertWlanToEthHeader (TI_HANDLE hRxData, void *pBuffer, TI_UINT16 * etherType)
1372 {
1373     TEthernetHeader      EthHeader;
1374     Wlan_LlcHeader_T    *pWlanSnapHeader;
1375     TI_UINT8            *dataBuf;
1376     dot11_header_t      *pDot11Header;
1377     TI_UINT32            lengthDelta;
1378     TI_UINT16            swapedTypeLength;
1379     TI_UINT32            headerLength;
1380     TI_UINT8             createEtherIIHeader;
1381     rxData_t *pRxData = (rxData_t *)hRxData;
1382
1383     dataBuf = (TI_UINT8 *)RX_BUF_DATA(pBuffer);
1384
1385     /* Setting the mac header len according to the received FrameControl field in the Mac Header */
1386     GET_MAX_HEADER_SIZE (dataBuf, &headerLength);
1387     pDot11Header = (dot11_header_t*) dataBuf;
1388     pWlanSnapHeader = (Wlan_LlcHeader_T*)((TI_UINT32)dataBuf + (TI_UINT32)headerLength);
1389
1390     swapedTypeLength = WLANTOHS (pWlanSnapHeader->Type);
1391     *etherType = swapedTypeLength;
1392
1393     /* Prepare the Ethernet header. */
1394     if( ENDIAN_HANDLE_WORD(pDot11Header->fc) & DOT11_FC_FROM_DS)
1395     {   /* Infrastructure  bss */
1396         MAC_COPY (EthHeader.dst, pDot11Header->address1);
1397         MAC_COPY (EthHeader.src, pDot11Header->address3);
1398     }
1399     else
1400     {   /* Independent bss */
1401         MAC_COPY (EthHeader.dst, pDot11Header->address1);
1402         MAC_COPY (EthHeader.src, pDot11Header->address2);
1403     }
1404
1405     createEtherIIHeader = TI_FALSE;
1406         /* See if the LLC header in the frame shows the SAP SNAP... */
1407         if((SNAP_CHANNEL_ID == pWlanSnapHeader->DSAP) &&
1408            (SNAP_CHANNEL_ID == pWlanSnapHeader->SSAP) &&
1409            (LLC_CONTROL_UNNUMBERED_INFORMATION == pWlanSnapHeader->Control))
1410         {
1411                 /* Check for the Bridge Tunnel OUI in the SNAP Header... */
1412                 if((SNAP_OUI_802_1H_BYTE0 == pWlanSnapHeader->OUI[ 0 ]) &&
1413                    (SNAP_OUI_802_1H_BYTE1 == pWlanSnapHeader->OUI[ 1 ]) &&
1414                    (SNAP_OUI_802_1H_BYTE2 == pWlanSnapHeader->OUI[ 2 ]))
1415                 {
1416                         /* Strip the SNAP header by skipping over it.                  */
1417                         /* Start moving data from the Ethertype field in the SNAP      */
1418                         /* header.  Move to the TypeLength field in the 802.3 header.  */
1419                         createEtherIIHeader = TI_TRUE;
1420                 }
1421                 /* Check for the RFC 1042 OUI in the SNAP Header   */
1422                 else
1423                 {
1424                         /* Check for the RFC 1042 OUI in the SNAP Header   */
1425                         if(     (SNAP_OUI_RFC1042_BYTE0 == pWlanSnapHeader->OUI[ 0 ]) &&
1426                                 (SNAP_OUI_RFC1042_BYTE1 == pWlanSnapHeader->OUI[ 1 ]) &&
1427                                 (SNAP_OUI_RFC1042_BYTE2 == pWlanSnapHeader->OUI[ 2 ]))
1428                         {
1429                         /* See if the Ethertype is in our selective translation table  */
1430                         /* (Appletalk AARP and DIX II IPX are the two protocols in     */
1431                         /* our 'table')                                                */
1432                                 if((ETHERTYPE_APPLE_AARP != swapedTypeLength) &&
1433                                         (ETHERTYPE_DIX_II_IPX != swapedTypeLength))
1434                         {
1435                                 /* Strip the SNAP header by skipping over it. */
1436                                 createEtherIIHeader = TI_TRUE;
1437                         }
1438                 }
1439         }
1440     }
1441
1442     if( createEtherIIHeader == TI_TRUE )
1443     {
1444     /* The LEN/TYPE bytes are set to TYPE, the entire WLAN+SNAP is removed.*/
1445     lengthDelta = headerLength + WLAN_SNAP_HDR_LEN - ETHERNET_HDR_LEN;
1446     EthHeader.type = pWlanSnapHeader->Type;
1447     }
1448     else
1449     {
1450         /* The LEN/TYPE bytes are set to frame LEN, only the WLAN header is removed, */
1451         /* the entire 802.3 or 802.2 header is not removed.*/
1452         lengthDelta = headerLength - ETHERNET_HDR_LEN;
1453         EthHeader.type = WLANTOHS((TI_UINT16)(RX_BUF_LEN(pBuffer) - headerLength));
1454     }
1455
1456     /* Replace the 802.11 header and the LLC with Ethernet packet. */
1457     dataBuf += lengthDelta;
1458     os_memoryCopy (pRxData->hOs, dataBuf, (void*)&EthHeader, ETHERNET_HDR_LEN);
1459     RX_ETH_PKT_DATA(pBuffer) = dataBuf;
1460     RX_ETH_PKT_LEN(pBuffer)  = RX_BUF_LEN(pBuffer) - lengthDelta;
1461
1462     return TI_OK;
1463 }
1464
1465
1466 /**
1467  * \brief convert A-MSDU to several ethernet packets
1468  *
1469  * \param hRxData - the object
1470  * \param pBuffer - the received Buffer in A-MSDU 802.11n format
1471  * \param pRxAttr - Rx attributes
1472  * \return TI_OK on success or TI_NOK on failure
1473  *
1474  * \par Description
1475  * Static function
1476  * This function convert the A-MSDU Packet from A-MSDU 802.11n packet
1477  * format to several ethernet packets format and pass them to the OS layer
1478  *
1479  * \sa
1480  */
1481 static TI_STATUS rxData_ConvertAmsduToEthPackets (TI_HANDLE hRxData, void *pBuffer, TRxAttr* pRxAttr)
1482 {
1483
1484     TEthernetHeader     *pMsduEthHeader;
1485     TEthernetHeader     *pEthHeader;
1486     Wlan_LlcHeader_T    *pWlanSnapHeader;
1487     TI_UINT8            *pAmsduDataBuf;
1488     TI_UINT16            uAmsduDataLen;
1489     void                *pDataBuf;
1490     TI_UINT16            uDataLen;
1491     TI_UINT32            lengthDelta;
1492     TI_UINT16            swapedTypeLength;
1493     TI_UINT32            headerLength;
1494     rxDataPacketType_e   DataPacketType;
1495     rxData_t            *pRxData = (rxData_t *)hRxData;
1496
1497     /* total AMPDU header */
1498     pAmsduDataBuf = (TI_UINT8 *)RX_BUF_DATA(pBuffer);
1499     /* Setting the mac header len according to the received FrameControl field in the Mac Header */
1500     GET_MAX_HEADER_SIZE (pAmsduDataBuf, &headerLength);
1501
1502     /*
1503      * init loop setting
1504      */
1505     /* total AMPDU size */
1506     uAmsduDataLen = (TI_UINT16)(RX_BUF_LEN(pBuffer) - headerLength);
1507     /* ETH header */
1508     pMsduEthHeader = (TEthernetHeader *)(pAmsduDataBuf + headerLength);
1509     /* ETH length, in A-MSDU the MSDU header type contain the MSDU length and not the type */
1510     uDataLen = WLANTOHS(pMsduEthHeader->type);
1511
1512     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ConvertAmsduToEthPackets(): A-MSDU received in length %d \n",uAmsduDataLen);
1513
1514     /* if we have another packet at the AMSDU */
1515     while((uDataLen < uAmsduDataLen) && (uAmsduDataLen > ETHERNET_HDR_LEN + FCS_SIZE))
1516     {
1517         /* allocate a new buffer */
1518         /* RxBufAlloc() add an extra word for alignment the MAC payload */
1519         rxData_RequestForBuffer (hRxData, &pDataBuf, sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen, 0, TAG_CLASS_AMSDU);
1520         if (NULL == pDataBuf)
1521         {
1522             TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ConvertAmsduToEthPackets(): cannot alloc MSDU packet. length %d \n",uDataLen);
1523             rxData_discardPacket (hRxData, pBuffer, pRxAttr);
1524             return TI_NOK;
1525         }
1526
1527         /* read packet type from LLC */
1528         pWlanSnapHeader = (Wlan_LlcHeader_T*)((TI_UINT8*)pMsduEthHeader + ETHERNET_HDR_LEN);
1529         swapedTypeLength = WLANTOHS (pWlanSnapHeader->Type);
1530
1531         /* copy the RxIfDescriptor */
1532         os_memoryCopy (pRxData->hOs, pDataBuf, pBuffer, sizeof(RxIfDescriptor_t));
1533
1534         /* update length, in the RxIfDescriptor the Len in words (4B) */
1535         ((RxIfDescriptor_t *)pDataBuf)->length = (sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen) >> 2;
1536         ((RxIfDescriptor_t *)pDataBuf)->extraBytes = 4 - ((sizeof(RxIfDescriptor_t) + WLAN_SNAP_HDR_LEN + ETHERNET_HDR_LEN + uDataLen) & 0x3);
1537
1538         /* Prepare the Ethernet header pointer. */
1539         /* add padding in the start of the buffer in order to align ETH payload */
1540         pEthHeader = (TEthernetHeader *)((TI_UINT8 *)(RX_BUF_DATA(pDataBuf)) +
1541                                          WLAN_SNAP_HDR_LEN +
1542                                          PADDING_ETH_PACKET_SIZE);
1543
1544         /* copy the Ethernet header */
1545         os_memoryCopy (pRxData->hOs, pEthHeader, pMsduEthHeader, ETHERNET_HDR_LEN);
1546
1547         /* The LEN/TYPE bytes are set to TYPE */
1548         pEthHeader->type = pWlanSnapHeader->Type;
1549
1550         /* Delta length for the next packet */
1551         lengthDelta = ETHERNET_HDR_LEN + uDataLen;
1552
1553         /* copy the packet payload */
1554         if (uDataLen > WLAN_SNAP_HDR_LEN)
1555             os_memoryCopy (pRxData->hOs,
1556                        (((TI_UINT8*)pEthHeader) + ETHERNET_HDR_LEN),
1557                        ((TI_UINT8*)pMsduEthHeader) + ETHERNET_HDR_LEN + WLAN_SNAP_HDR_LEN,
1558                        uDataLen - WLAN_SNAP_HDR_LEN);
1559
1560         /* set the packet type */
1561         if (swapedTypeLength == ETHERTYPE_802_1D)
1562         {
1563             TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received VLAN Buffer  \n");
1564
1565             DataPacketType = DATA_VLAN_PACKET;
1566         }
1567         else if (HTOWLANS(pEthHeader->type) == EAPOL_PACKET)
1568         {
1569             TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received Eapol pBuffer  \n");
1570
1571             DataPacketType = DATA_EAPOL_PACKET;
1572         }
1573         else
1574         {
1575             TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, " rxData_ConvertAmsduToEthPackets() : Received Data pBuffer  \n");
1576
1577             DataPacketType = DATA_DATA_PACKET;
1578         }
1579
1580         /* update buffer setting */
1581         /* save the ETH packet address */
1582         RX_ETH_PKT_DATA(pDataBuf) = pEthHeader;
1583         /* save the ETH packet size */
1584         RX_ETH_PKT_LEN(pDataBuf) = uDataLen + ETHERNET_HDR_LEN - WLAN_SNAP_HDR_LEN;
1585
1586         /* star of MSDU packet always align acceding to 11n spec */
1587         lengthDelta = (lengthDelta + ALIGN_4BYTE_MASK) & ~ALIGN_4BYTE_MASK;
1588         pMsduEthHeader = (TEthernetHeader *)(((TI_UINT8*)pMsduEthHeader) + lengthDelta);
1589
1590         if(uAmsduDataLen > lengthDelta)
1591         {
1592             /* swich to the next MSDU */
1593             uAmsduDataLen = uAmsduDataLen - lengthDelta;
1594
1595             /* Clear the EndOfBurst flag for all packets except the last one */
1596             ((RxIfDescriptor_t *)pDataBuf)->driverFlags &= ~DRV_RX_FLAG_END_OF_BURST;
1597         }
1598         else
1599         {
1600             /* no more MSDU */
1601             uAmsduDataLen = 0;
1602         }
1603
1604
1605         /* in A-MSDU the MSDU header type contain the MSDU length and not the type */
1606         uDataLen = WLANTOHS(pMsduEthHeader->type);
1607
1608
1609         /* dispatch Buffer according to packet type and current rx data port status */
1610         pRxData->rxData_dispatchBuffer[pRxData->rxDataPortStatus][DataPacketType] (hRxData, pDataBuf, pRxAttr);
1611
1612     } /* while end */
1613
1614
1615     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ConvertAmsduToEthPackets(): A-MSDU Packe conversion done.\n");
1616
1617     /* free the A-MSDU packet */
1618     RxBufFree(pRxData->hOs, pBuffer);
1619
1620     return TI_OK;
1621 }
1622
1623 /****************************************************************************************
1624  *                        rxData_ReceivePacket                                              *
1625  ****************************************************************************************
1626 DESCRIPTION:    receive packet CB from RxXfer.
1627                 parse the status and other parameters and forward the frame to
1628                 rxData_receivePacketFromWlan()
1629
1630 INPUT:          Rx frame with its parameters
1631
1632 OUTPUT:
1633
1634 RETURN:
1635
1636 ************************************************************************/
1637 static void rxData_ReceivePacket (TI_HANDLE   hRxData,
1638                                   void  *pBuffer)
1639 {
1640     rxData_t            *pRxData    = (rxData_t *)hRxData;
1641
1642     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION, "rxData_ReceivePacket: Received BUF %x\n", pBuffer);
1643
1644     if (pBuffer)
1645     {
1646         RxIfDescriptor_t    *pRxParams  = (RxIfDescriptor_t*)pBuffer;
1647         TRxAttr             RxAttr;
1648         ERate               appRate;
1649         dot11_header_t      *pHdr;
1650
1651         /*
1652          * First thing we do is getting the dot11_header, and than we check the status, since the header is
1653          * needed for RX_MIC_FAILURE_ERROR
1654          */
1655
1656         pHdr = (dot11_header_t *)RX_BUF_DATA(pBuffer);
1657
1658         /* Check status */
1659         switch (pRxParams->status & RX_DESC_STATUS_MASK)
1660         {
1661             case RX_DESC_STATUS_SUCCESS:
1662                 break;
1663
1664             case RX_DESC_STATUS_DECRYPT_FAIL:
1665             {
1666                 /* This error is not important before the Connection, so we ignore it when portStatus is not OPEN */
1667                 if (pRxData->rxDataPortStatus == OPEN)
1668                 {
1669                     TRACE0(pRxData->hReport, REPORT_SEVERITY_WARNING, "rxData_ReceivePacket: Received Packet with RX_DESC_DECRYPT_FAIL\n");
1670                 }
1671
1672                 RxBufFree(pRxData->hOs, pBuffer);
1673                 return;
1674             }
1675             case RX_DESC_STATUS_MIC_FAIL:
1676             {
1677                 TI_UINT8 uKeyType;
1678                 paramInfo_t Param;
1679                 TMacAddr* pMac = &pHdr->address1; /* hold the first mac address */
1680                 /* Get BSS type */
1681                 Param.paramType = SITE_MGR_CURRENT_BSS_TYPE_PARAM;
1682                 siteMgr_getParam (pRxData->hSiteMgr, &Param);
1683
1684                 /* For multicast/broadcast frames or in IBSS the key used is GROUP, else - it's Pairwise */
1685                 if (MAC_MULTICAST(*pMac) || Param.content.siteMgrCurrentBSSType == BSS_INDEPENDENT)
1686                 {
1687                     uKeyType = (TI_UINT8)KEY_TKIP_MIC_GROUP;
1688                         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet MIC failure. Type = Group\n");
1689                 }
1690                 /* Unicast on infrastructure */
1691                 else
1692                 {
1693                     uKeyType = (TI_UINT8)KEY_TKIP_MIC_PAIRWISE;
1694                         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet MIC failure. Type = Pairwise\n");
1695                 }
1696
1697
1698                 rsn_reportMicFailure (pRxData->hRsn, &uKeyType, sizeof(uKeyType));
1699                 RxBufFree(pRxData->hOs, pBuffer);
1700                 return;
1701             }
1702
1703             case RX_DESC_STATUS_DRIVER_RX_Q_FAIL:
1704             {
1705                 /* Rx queue error - free packet and return */
1706                 TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet with Rx queue error \n");
1707
1708                 RxBufFree(pRxData->hOs, pBuffer);
1709                 return;
1710             }
1711
1712             default:
1713                     /* Unknown error - free packet and return */
1714                     TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR, "rxData_ReceivePacket: Received Packet with unknown status = %d\n", (pRxParams->status & RX_DESC_STATUS_MASK));
1715
1716                     RxBufFree(pRxData->hOs, pBuffer);
1717                     return;
1718             }
1719
1720         TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Receive good Packet\n");
1721
1722         if (rate_PolicyToDrv ((ETxRateClassId)(pRxParams->rate), &appRate) != TI_OK)
1723         {
1724             TRACE1(pRxData->hReport, REPORT_SEVERITY_ERROR , "rxData_ReceivePacket: can't convert hwRate=0x%x\n", pRxParams->rate);
1725         }
1726
1727         /*
1728          * Set rx attributes
1729          */
1730         RxAttr.channel    = pRxParams->channel;
1731         RxAttr.packetInfo = pRxParams->flags;
1732         RxAttr.ePacketType= pRxParams->packet_class_tag;
1733         RxAttr.Rate       = appRate;
1734         RxAttr.Rssi       = pRxParams->rx_level;
1735         RxAttr.SNR        = pRxParams->rx_snr;
1736         RxAttr.status     = pRxParams->status & RX_DESC_STATUS_MASK;
1737         /* for now J band not implemented */
1738         RxAttr.band       = ((pRxParams->flags & RX_DESC_BAND_MASK) == RX_DESC_BAND_A) ?
1739                             RADIO_BAND_5_0_GHZ : RADIO_BAND_2_4_GHZ ;
1740         RxAttr.eScanTag   = (EScanResultTag)(pRxParams->proccess_id_tag);
1741         /* timestamp is 32 bit so do bytes copy to avoid exception in case the RxInfo is in 2 bytes offset */
1742         os_memoryCopy (pRxData->hOs,
1743                        (void *)&(RxAttr.TimeStamp),
1744                        (void *)&(pRxParams->timestamp),
1745                        sizeof(pRxParams->timestamp) );
1746         RxAttr.TimeStamp = ENDIAN_HANDLE_LONG(RxAttr.TimeStamp);
1747
1748         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);
1749
1750         rxData_receivePacketFromWlan (hRxData, pBuffer, &RxAttr);
1751
1752         /*
1753          *  Buffer MUST be freed until now
1754          */
1755     }
1756     else
1757     {
1758         TRACE0(pRxData->hReport, REPORT_SEVERITY_ERROR , "rxData_ReceivePacket: null Buffer received");
1759     }
1760 }
1761
1762
1763 /****************************************************************************************
1764  *                        rxData_RequestForBuffer                                              *
1765  ****************************************************************************************
1766 DESCRIPTION:     RX request for buffer
1767                 uEncryptionflag API are for GWSI use.
1768 INPUT:
1769
1770 OUTPUT:
1771
1772 RETURN:
1773
1774 ************************************************************************/
1775 static ERxBufferStatus rxData_RequestForBuffer (TI_HANDLE   hRxData,
1776                                       void **pBuf,
1777                                       TI_UINT16 aLength,
1778                                       TI_UINT32 uEncryptionflag,
1779                                       PacketClassTag_e ePacketClassTag)
1780 {
1781     rxData_t *pRxData = (rxData_t *)hRxData;
1782
1783     TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION , " RequestForBuffer, length = %d \n",aLength);
1784
1785     *pBuf = RxBufAlloc (pRxData->hOs, aLength, ePacketClassTag);
1786
1787     if (*pBuf)
1788     {
1789         return RX_BUF_ALLOC_COMPLETE;
1790     }
1791     else
1792     {
1793         return RX_BUF_ALLOC_OUT_OF_MEM;
1794     }
1795 }
1796
1797
1798 /*******************************************************************
1799 *                        DEBUG FUNCTIONS                           *
1800 *******************************************************************/
1801
1802 #ifdef TI_DBG
1803
1804 /***************************************************************************
1805 *                        rxData_resetCounters                              *
1806 ****************************************************************************
1807 * DESCRIPTION:  This function reset the Rx Data module counters
1808 *
1809 * INPUTS:       hRxData - the object
1810 *
1811 * OUTPUT:
1812 *
1813 * RETURNS:      void
1814 ***************************************************************************/
1815 void rxData_resetCounters(TI_HANDLE hRxData)
1816 {
1817     rxData_t *pRxData = (rxData_t *)hRxData;
1818
1819     os_memoryZero(pRxData->hOs, &pRxData->rxDataCounters, sizeof(rxDataCounters_t));
1820 }
1821
1822 /***************************************************************************
1823 *                        rxData_resetDbgCounters                           *
1824 ****************************************************************************
1825 * DESCRIPTION:  This function reset the Rx Data module debug counters
1826 *
1827 * INPUTS:       hRxData - the object
1828 *
1829 * OUTPUT:
1830 *
1831 * RETURNS:      void
1832 ***************************************************************************/
1833
1834 void rxData_resetDbgCounters(TI_HANDLE hRxData)
1835 {
1836     rxData_t *pRxData = (rxData_t *)hRxData;
1837
1838     os_memoryZero(pRxData->hOs, &pRxData->rxDataDbgCounters, sizeof(rxDataDbgCounters_t));
1839 }
1840
1841
1842 /***************************************************************************
1843 *                            test functions                                *
1844 ***************************************************************************/
1845 void rxData_printRxCounters (TI_HANDLE hRxData)
1846 {
1847 #ifdef REPORT_LOG
1848     rxData_t *pRxData = (rxData_t *)hRxData;
1849
1850     if (pRxData)
1851     {
1852         WLAN_OS_REPORT(("RecvOk = %d\n", pRxData->rxDataCounters.RecvOk));
1853         WLAN_OS_REPORT(("DirectedBytesRecv = %d\n", pRxData->rxDataCounters.DirectedBytesRecv));
1854         WLAN_OS_REPORT(("DirectedFramesRecv = %d\n", pRxData->rxDataCounters.DirectedFramesRecv));
1855         WLAN_OS_REPORT(("MulticastBytesRecv = %d\n", pRxData->rxDataCounters.MulticastBytesRecv));
1856         WLAN_OS_REPORT(("MulticastFramesRecv = %d\n", pRxData->rxDataCounters.MulticastFramesRecv));
1857         WLAN_OS_REPORT(("BroadcastBytesRecv = %d\n", pRxData->rxDataCounters.BroadcastBytesRecv));
1858         WLAN_OS_REPORT(("BroadcastFramesRecv = %d\n", pRxData->rxDataCounters.BroadcastFramesRecv));
1859
1860         /* debug counters */
1861         WLAN_OS_REPORT(("excludedFrameCounter = %d\n", pRxData->rxDataDbgCounters.excludedFrameCounter));
1862         WLAN_OS_REPORT(("rxDroppedDueToVLANIncludedCnt = %d\n", pRxData->rxDataDbgCounters.rxDroppedDueToVLANIncludedCnt));
1863         WLAN_OS_REPORT(("rxWrongBssTypeCounter = %d\n", pRxData->rxDataDbgCounters.rxWrongBssTypeCounter));
1864         WLAN_OS_REPORT(("rxWrongBssIdCounter = %d\n", pRxData->rxDataDbgCounters.rxWrongBssIdCounter));
1865         WLAN_OS_REPORT(("rcvUnicastFrameInOpenNotify = %d\n", pRxData->rxDataDbgCounters.rcvUnicastFrameInOpenNotify));
1866     }
1867 #endif
1868 }
1869
1870
1871 void rxData_printRxBlock(TI_HANDLE hRxData)
1872 {
1873 #ifdef REPORT_LOG
1874     rxData_t *pRxData = (rxData_t *)hRxData;
1875
1876     WLAN_OS_REPORT(("hCtrlData = 0x%X\n", pRxData->hCtrlData));
1877     WLAN_OS_REPORT(("hMlme = 0x%X\n", pRxData->hMlme));
1878     WLAN_OS_REPORT(("hOs = 0x%X\n", pRxData->hOs));
1879     WLAN_OS_REPORT(("hReport = 0x%X\n", pRxData->hReport));
1880     WLAN_OS_REPORT(("hRsn = 0x%X\n", pRxData->hRsn));
1881     WLAN_OS_REPORT(("hSiteMgr = 0x%X\n", pRxData->hSiteMgr));
1882
1883     WLAN_OS_REPORT(("hCtrlData = 0x%X\n", pRxData->hCtrlData));
1884     WLAN_OS_REPORT(("hMlme = 0x%X\n", pRxData->hMlme));
1885     WLAN_OS_REPORT(("hOs = 0x%X\n", pRxData->hOs));
1886     WLAN_OS_REPORT(("hReport = 0x%X\n", pRxData->hReport));
1887     WLAN_OS_REPORT(("hRsn = 0x%X\n", pRxData->hRsn));
1888     WLAN_OS_REPORT(("hSiteMgr = 0x%X\n", pRxData->hSiteMgr));
1889
1890     WLAN_OS_REPORT(("rxDataPortStatus = %d\n", pRxData->rxDataPortStatus));
1891     WLAN_OS_REPORT(("rxDataExcludeUnencrypted = %d\n", pRxData->rxDataExcludeUnencrypted));
1892     WLAN_OS_REPORT(("rxDataEapolDestination = %d\n", pRxData->rxDataEapolDestination));
1893 #endif
1894 }
1895
1896
1897 void rxData_startRxThroughputTimer (TI_HANDLE hRxData)
1898 {
1899     rxData_t *pRxData = (rxData_t *)hRxData;
1900
1901     if (!pRxData->rxThroughputTimerEnable)
1902     {
1903         /* reset throughput counter */
1904         pRxData->rxDataCounters.LastSecBytesRecv = 0;
1905         pRxData->rxThroughputTimerEnable = TI_TRUE;
1906
1907         /* start 1 sec throughput timer */
1908         tmr_StartTimer (pRxData->hThroughputTimer,
1909                         rxData_printRxThroughput,
1910                         (TI_HANDLE)pRxData,
1911                         1000,
1912                         TI_TRUE);
1913     }
1914 }
1915
1916
1917 void rxData_stopRxThroughputTimer (TI_HANDLE hRxData)
1918 {
1919
1920     rxData_t *pRxData = (rxData_t *)hRxData;
1921
1922     if (pRxData->rxThroughputTimerEnable)
1923     {
1924         tmr_StopTimer (pRxData->hThroughputTimer);
1925         pRxData->rxThroughputTimerEnable = TI_FALSE;
1926     }
1927 }
1928
1929
1930 static void rxData_printRxThroughput (TI_HANDLE hRxData, TI_BOOL bTwdInitOccured)
1931 {
1932     rxData_t *pRxData = (rxData_t *)hRxData;
1933
1934     WLAN_OS_REPORT (("\n"));
1935     WLAN_OS_REPORT (("-------------- Rx Throughput Statistics ---------------\n"));
1936     WLAN_OS_REPORT (("Throughput = %d KBits/sec\n", pRxData->rxDataCounters.LastSecBytesRecv * 8 / 1024));
1937
1938     /* reset throughput counter */
1939     pRxData->rxDataCounters.LastSecBytesRecv = 0;
1940 }
1941
1942 void rxData_printRxDataFilter (TI_HANDLE hRxData)
1943 {
1944     TI_UINT32 index;
1945     rxData_t *pRxData = (rxData_t *)hRxData;
1946
1947     for (index=0; index<MAX_DATA_FILTERS; index++)
1948      {
1949         if (pRxData->isFilterSet[index])
1950         {
1951             WLAN_OS_REPORT (("index=%d, pattern & mask\n", index));
1952             report_PrintDump(pRxData->filterRequests[index].pattern, pRxData->filterRequests[index].patternLength);
1953             report_PrintDump(pRxData->filterRequests[index].mask, pRxData->filterRequests[index].maskLength);
1954         }
1955         else
1956         {
1957             WLAN_OS_REPORT (("No Filter defined for index-%d\n", index));
1958         }
1959      }
1960 }
1961
1962 #endif /*TI_DBG*/
1963
1964 /****************************************************************************
1965  *                      rxData_SetReAuthInProgress()
1966  ****************************************************************************
1967  * DESCRIPTION: Sets the ReAuth flag value
1968  *
1969  * INPUTS: hRxData - the object
1970  *                 value - value to set the flag to
1971  *
1972  * OUTPUT:      None
1973  *
1974  * RETURNS:     OK or NOK
1975  ****************************************************************************/
1976 void rxData_SetReAuthInProgress(TI_HANDLE hRxData, TI_BOOL      value)
1977 {
1978         rxData_t *pRxData = (rxData_t *)hRxData;
1979
1980         TRACE1(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Set ReAuth flag to %d\n", value);
1981
1982         pRxData->reAuthInProgress = value;
1983 }
1984
1985 /****************************************************************************
1986  *                      rxData_IsReAuthInProgress()
1987  ****************************************************************************
1988  * DESCRIPTION: Returns the ReAuth flag value
1989  *
1990  * INPUTS: hRxData - the object
1991  *
1992  * OUTPUT:      None
1993  *
1994  * RETURNS:     ReAuth flag value
1995  ****************************************************************************/
1996 TI_BOOL rxData_IsReAuthInProgress(TI_HANDLE hRxData)
1997 {
1998         rxData_t *pRxData = (rxData_t *)hRxData;
1999         return pRxData->reAuthInProgress;
2000 }
2001
2002 /****************************************************************************
2003 *                                               rxData_StartReAuthActiveTimer                           *
2004 *****************************************************************************
2005 * DESCRIPTION:  this function starts the ReAuthActive timer
2006 *
2007 * INPUTS:               hRxData - the object
2008 *
2009 * OUTPUT:               None
2010 *
2011 * RETURNS:              None
2012 ***************************************************************************/
2013 static void rxData_StartReAuthActiveTimer(TI_HANDLE hRxData)
2014 {
2015         rxData_t *pRxData = (rxData_t *)hRxData;
2016     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Start ReAuth Active Timer\n");
2017     tmr_StartTimer (pRxData->reAuthActiveTimer,
2018                     reAuthTimeout,
2019                     (TI_HANDLE)pRxData,
2020                     pRxData->reAuthActiveTimeout,
2021                     TI_FALSE);
2022 }
2023
2024 /****************************************************************************
2025 *                                               rxData_StopReAuthActiveTimer                                            *
2026 *****************************************************************************
2027 * DESCRIPTION:  this function stops the ReAuthActive timer
2028 *
2029 * INPUTS:               hRxData - the object
2030 *
2031 * OUTPUT:               None
2032 *
2033 * RETURNS:              None
2034 ***************************************************************************/
2035 void rxData_StopReAuthActiveTimer(TI_HANDLE hRxData)
2036 {
2037         rxData_t *pRxData = (rxData_t *)hRxData;
2038     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "Stop ReAuth Active Timer\n");
2039     tmr_StopTimer (pRxData->reAuthActiveTimer);
2040 }
2041
2042 /****************************************************************************
2043 *                                               reAuthTimeout                                                                           *
2044 *****************************************************************************
2045 * DESCRIPTION:  this function ia called when the ReAuthActive timer elapses
2046 *                               It resets the Reauth flag and restore the PS state.
2047 *                               It also sends RE_AUTH_TERMINATED event to upper layer.
2048 *
2049 * INPUTS:               hRxData - the object
2050 *
2051 * OUTPUT:               None
2052 *
2053 * RETURNS:              None
2054 ***************************************************************************/
2055 static void reAuthTimeout(TI_HANDLE hRxData, TI_BOOL bTwdInitOccured)
2056 {
2057         rxData_t *pRxData = (rxData_t *)hRxData;
2058
2059     TRACE0(pRxData->hReport, REPORT_SEVERITY_INFORMATION , "ReAuth Active Timeout\n");
2060         rxData_SetReAuthInProgress(pRxData, TI_FALSE);
2061         rxData_ReauthDisablePriority(pRxData);
2062     EvHandlerSendEvent(pRxData->hEvHandler, IPC_EVENT_RE_AUTH_TERMINATED, NULL, 0);
2063 }
2064
2065 void rxData_ReauthEnablePriority(TI_HANDLE hRxData)
2066 {
2067         rxData_t *pRxData = (rxData_t *)hRxData;
2068         paramInfo_t param;
2069
2070     param.paramType = POWER_MGR_ENABLE_PRIORITY;
2071     param.content.powerMngPriority = POWER_MANAGER_REAUTH_PRIORITY;
2072     powerMgr_setParam(pRxData->hPowerMgr,&param);
2073 }
2074
2075 void rxData_ReauthDisablePriority(TI_HANDLE hRxData)
2076 {
2077         rxData_t *pRxData = (rxData_t *)hRxData;
2078     paramInfo_t param;
2079
2080     param.paramType = POWER_MGR_DISABLE_PRIORITY;
2081     param.content.powerMngPriority = POWER_MANAGER_REAUTH_PRIORITY;
2082     powerMgr_setParam(pRxData->hPowerMgr,&param);
2083 }