/* * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * * * Permission to use, copy, modify, and/or distribute this software for * any purpose with or without fee is hereby granted, provided that the * above copyright notice and this permission notice appear in all * copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ /* * This file was originally distributed by Qualcomm Atheros, Inc. * under proprietary terms before Copyright ownership was assigned * to the Linux Foundation. */ /*=========================================================================== W L A N _ Q C T _ T L . C OVERVIEW: This software unit holds the implementation of the WLAN Transport Layer. The functions externalized by this module are to be called ONLY by other WLAN modules that properly register with the Transport Layer initially. DEPENDENCIES: Are listed for each API below. ===========================================================================*/ /*=========================================================================== EDIT HISTORY FOR FILE This section contains comments describing changes made to the module. Notice that changes are listed in reverse chronological order. $Header$$DateTime$$Author$ when who what, where, why ---------- --- -------------------------------------------------------- 2013-08-19 rajekuma Added RMC support 2010-07-13 c_shinde Fixed an issue where WAPI rekeying was failing because WAI frame sent out during rekeying had the protected bit set to 1. 2010-05-06 rnair Changed name of variable from usLlcType to usEtherType Changed function name from GetLLCType to GetEtherType Fixed 802.3 to 802.11 frame translation issue where two bytes of the LLC header was getting overwritten in the non-Qos path 2010-05-06 rnair RxAuth path fix for modifying the header before ether type is retreived (Detected while testing rekeying in WAPI Volans) 2010-02-19 bad Fixed 802.11 to 802.3 ft issues with WAPI 2010-02-19 rnair WAPI: If frame is a WAI frame in TxConn and TxAuth, TL does frame translation. 2010-02-01 rnair WAPI: Fixed a bug where the value of ucIsWapiSta was not being set in the TL control block in the RegisterSTA func. 2010-01-08 lti Added TL Data Caching 2009-11-04 rnair WAPI: Moving common functionality to a seperate function called WLANTL_GetLLCType 2009-10-15 rnair WAPI: Featurizing WAPI code 2009-10-09 rnair WAPI: Modifications to authenticated state handling of Rx data 2009-10-06 rnair Adding support for WAPI 2009-09-22 lti Add deregistration API for management client 2009-07-16 rnair Temporary fix to let TL fetch packets when multiple peers exist in an IBSS 2009-06-10 lti Fix for checking TID value of meta info on TX - prevent memory overwrite Fix for properly checking the sta id for resuming trigger frame generation 2009-05-14 lti Fix for sending out trigger frames 2009-05-15 lti Addr3 filtering 2009-04-13 lti Assert if packet larger then allowed Drop packet that fails flatten 2009-04-02 lti Performance fixes for TL 2009-02-19 lti Added fix for LLC management on Rx Connect 2009-01-16 lti Replaced peek data with extract data for non BD opertions Extracted frame control in Tl and pass to HAL for frame type evaluation 2009-02-02 sch Add handoff support 2008-12-09 lti Fixes for AMSS compilation Removed assert on receive when there is no station 2008-12-02 lti Fix fo trigger frame generation 2008-10-31 lti Fix fo TL tx suspend 2008-10-01 lti Merged in fixes from reordering Disabled part of UAPSD functionality in TL (will be re-enabled once UAPSD is tested) Fix for UAPSD multiple enable 2008-08-10 lti Fixes following UAPSD testing Fixed infinite loop on mask computation when STA no reg 2008-08-06 lti Fixes after QOS unit testing 2008-08-06 lti Added QOS support 2008-07-23 lti Fix for vos packet draining 2008-07-17 lti Fix for data type value Added frame translation code in TL Avoid returning failure to PE in case previous frame is still pending; fail previous and cache new one for tx Get frames returning boolean true if more frames are pending 2008-07-03 lti Fixes following pre-integration testing 2008-06-26 lti Fixes following unit testing Added alloc and free for TL context Using atomic set u8 instead of u32 2008-05-16 lti Created module ===========================================================================*/ /*---------------------------------------------------------------------------- * Include Files * -------------------------------------------------------------------------*/ #include "wlan_qct_tl.h" #include "wlan_qct_wda.h" #include "wlan_qct_tli.h" #include "wlan_qct_tli_ba.h" #include "wlan_qct_tl_hosupport.h" #include "vos_types.h" #include "vos_trace.h" #include "wlan_qct_tl_trace.h" #include "tlDebug.h" #include "cfgApi.h" #ifdef FEATURE_WLAN_WAPI /*Included to access WDI_RxBdType */ #include "wlan_qct_wdi_bd.h" #endif /*Enables debugging behavior in TL*/ #define TL_DEBUG /*Enables debugging FC control frame in TL*/ //#define TL_DEBUG_FC //#define WLAN_SOFTAP_FLOWCTRL_EN //#define BTAMP_TEST #ifdef TL_DEBUG_FC #include #include // wpalReadRegister #endif /*---------------------------------------------------------------------------- * Preprocessor Definitions and Constants * -------------------------------------------------------------------------*/ /*LLC header value*/ static v_U8_t WLANTL_LLC_HEADER[] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00 }; #ifdef FEATURE_WLAN_ESE /*Aironet SNAP header value*/ static v_U8_t WLANTL_AIRONET_SNAP_HEADER[] = {0xAA, 0xAA, 0x03, 0x00, 0x40, 0x96, 0x00, 0x00 }; #endif //FEATURE_WLAN_ESE /*BT-AMP packet LLC OUI value*/ const v_U8_t WLANTL_BT_AMP_OUI[] = {0x00, 0x19, 0x58 }; #ifdef WLAN_FEATURE_LINK_LAYER_STATS extern const v_U8_t WLANTL_TID_2_AC[WLAN_MAX_TID]; #endif #define WLANTL_MAX_SNR_DATA_SAMPLES 20 #ifdef VOLANS_PERF #define WLANTL_BD_PDU_INTERRUPT_ENABLE_THRESHOLD 120 #define WLANTL_BD_PDU_INTERRUPT_GET_THRESHOLD 120 /* TL BD/PDU threshold to enable interrupt */ int bdPduInterruptEnableThreshold = WLANTL_BD_PDU_INTERRUPT_ENABLE_THRESHOLD; int bdPduInterruptGetThreshold = WLANTL_BD_PDU_INTERRUPT_GET_THRESHOLD; #endif /* VOLANS_PERF */ /*-----------------------------------* | Type(2b) | Sub-type(4b) | *-----------------------------------*/ #define WLANTL_IS_DATA_FRAME(_type_sub) \ ( WLANTL_DATA_FRAME_TYPE == ( (_type_sub) & 0x30 )) #define WLANTL_IS_QOS_DATA_FRAME(_type_sub) \ (( WLANTL_DATA_FRAME_TYPE == ( (_type_sub) & 0x30 )) && \ ( WLANTL_80211_DATA_QOS_SUBTYPE == ( (_type_sub) & 0xF ))) #define WLANTL_IS_MGMT_FRAME(_type_sub) \ ( WLANTL_MGMT_FRAME_TYPE == ( (_type_sub) & 0x30 )) #define WLANTL_IS_MGMT_ACTION_FRAME(_type_sub) \ (( WLANTL_MGMT_FRAME_TYPE == ( (_type_sub) & 0x30 )) && \ ( ( WLANTL_80211_MGMT_ACTION_SUBTYPE == ( (_type_sub) & 0xF )) || \ ( WLANTL_80211_MGMT_ACTION_NO_ACK_SUBTYPE == ( (_type_sub) & 0xF )))) #define WLANTL_IS_PROBE_REQ(_type_sub) \ ( WLANTL_MGMT_PROBE_REQ_FRAME_TYPE == ( (_type_sub) & 0x3F )) #define WLANTL_IS_CTRL_FRAME(_type_sub) \ ( WLANTL_CTRL_FRAME_TYPE == ( (_type_sub) & 0x30 )) #ifdef FEATURE_WLAN_TDLS #define WLANTL_IS_TDLS_FRAME(_eth_type) \ ( WLANTL_LLC_TDLS_TYPE == ( _eth_type)) #endif /*MAX Allowed len processed by TL - MAx MTU + 802.3 header + BD+DXE+XTL*/ #define WLANTL_MAX_ALLOWED_LEN (1514 + 100) #define WLANTL_DATA_FLOW_MASK 0x0F //some flow_control define //LWM mode will be enabled for this station if the egress/ingress falls below this ratio #define WLANTL_LWM_EGRESS_INGRESS_THRESHOLD (0.75) //Get enough sample to do the LWM related calculation #define WLANTL_LWM_INGRESS_SAMPLE_THRESHOLD (64) //Maximal on-fly packet per station in LWM mode #define WLANTL_STA_BMU_THRESHOLD_MAX (256) #define WLANTL_AC_MASK (0x7) #define WLANTL_STAID_OFFSET (0x6) /* UINT32 type endian swap */ #define SWAP_ENDIAN_UINT32(a) ((a) = ((a) >> 0x18 ) |(((a) & 0xFF0000) >> 0x08) | \ (((a) & 0xFF00) << 0x08) | (((a) & 0xFF) << 0x18)) /* Maximum value of SNR that can be calculated by the HW */ #define WLANTL_MAX_HW_SNR 35 #define DISABLE_ARP_TOGGLE 0 #define ENABLE_ARP_TOGGLE 1 #define SEND_ARP_ON_WQ5 2 #define WLANTL_RATE_RATIO_THRESHOLD 2 #define WLANTL_PER_THRESHOLD 5 #define WLANTL_QUEUE_THRESHOLD 60 #define WLANTL_GOOD_STA_WEIGHT 1 #define WLANTL_WEIGHT_THRESHOLD 50 /*---------------------------------------------------------------------------- * Type Declarations * -------------------------------------------------------------------------*/ #define TL_LITTLE_BIT_ENDIAN typedef struct { v_U8_t protVer :2; v_U8_t type :2; v_U8_t subType :4; v_U8_t toDS :1; v_U8_t fromDS :1; v_U8_t moreFrag :1; v_U8_t retry :1; v_U8_t powerMgmt :1; v_U8_t moreData :1; v_U8_t wep :1; v_U8_t order :1; } WLANTL_MACFCType; /* 802.11 header */ typedef struct { /* Frame control field */ WLANTL_MACFCType wFrmCtrl; /* Duration ID */ v_U16_t usDurationId; /* Address 1 field */ v_U8_t vA1[VOS_MAC_ADDR_SIZE]; /* Address 2 field */ v_U8_t vA2[VOS_MAC_ADDR_SIZE]; /* Address 3 field */ v_U8_t vA3[VOS_MAC_ADDR_SIZE]; /* Sequence control field */ v_U16_t usSeqCtrl; // Find the size of the mandatory header size. #define WLAN80211_MANDATORY_HEADER_SIZE \ (sizeof(WLANTL_MACFCType) + sizeof(v_U16_t) + \ (3 * (sizeof(v_U8_t) * VOS_MAC_ADDR_SIZE)) + \ sizeof(v_U16_t)) /* Optional A4 address */ v_U8_t optvA4[VOS_MAC_ADDR_SIZE]; /* Optional QOS control field */ v_U16_t usQosCtrl; }WLANTL_80211HeaderType; /* 802.3 header */ typedef struct { /* Destination address field */ v_U8_t vDA[VOS_MAC_ADDR_SIZE]; /* Source address field */ v_U8_t vSA[VOS_MAC_ADDR_SIZE]; /* Length field */ v_U16_t usLenType; }WLANTL_8023HeaderType; /*---------------------------------------------------------------------------- * Global Data Definitions * -------------------------------------------------------------------------*/ #define WLAN_TL_INVALID_U_SIG 255 #define WLAN_TL_INVALID_B_SIG 255 #define ENTER() VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__) #define WLAN_TL_AC_ARRAY_2_MASK( _pSTA, _ucACMask, i ) \ do\ {\ _ucACMask = 0; \ for ( i = 0; i < WLANTL_NUM_TX_QUEUES; i++ ) \ { \ if ( 0 != (_pSTA)->aucACMask[i] ) \ { \ _ucACMask |= ( 1 << i ); \ } \ } \ } while (0); /* Following is the copy of g11bRateInfo to understand rate index at TL */ #define WLANTL_MAX_RATE_NUM 137 typedef struct { uint32 phyRate; //unit in Mega bits per sec X 10 uint32 tputRate; //unit in Mega bits per sec X 10 uint32 tputBpms; //unit in Bytes per msec = (tputRateX1024x1024)/(8x10X1000) ~= (tputRate*13) uint32 tputBpus; //unit in Bytes per usec: round off to integral value }WLANTL_RateInfo; WLANTL_RateInfo gTLRateInfo[WLANTL_MAX_RATE_NUM] = { //11b rates { 10, 9, 117, 0}, //index 0 { 20, 17, 221, 0}, //index 1 { 55, 41, 533, 0}, //index 2 { 110, 68, 884, 0}, //index 3 //11b short preamble { 10, 10, 130, 0}, //index 4 { 20, 18, 234, 0}, //index 5 { 55, 44, 572, 0}, //index 6 { 110, 77, 1001, 0}, //index 7 //11ag { 60, 50, 650, 1}, //index 8 { 90, 70, 910, 1}, //index 9 { 120, 100, 1300, 1}, //index 10 { 180, 150, 1950, 2}, //index 11 { 240, 190, 2470, 2}, //index 12 { 360, 280, 3640, 4}, //index 13 { 480, 350, 4550, 5}, //index 14 { 540, 380, 4940, 6}, //index 15 //11n SIMO { 65, 54, 702, 1}, //index 16 { 130, 108, 1404, 1}, //index 17 { 195, 161, 2093, 2}, //index 18 { 260, 217, 2821, 3}, //index 19 { 390, 326, 4238, 4}, //index 20 { 520, 435, 5655, 6}, //index 21 { 585, 492, 6396, 6}, //index 22 { 650, 548, 7124, 7}, //index 23 //11n SIMO SGI { 72, 59, 767, 1}, //index 24 { 144, 118, 1534, 2}, //index 25 { 217, 180, 2340, 2}, //index 26 { 289, 243, 3159, 3}, //index 27 { 434, 363, 4719, 5}, //index 28 { 578, 486, 6318, 6}, //index 29 { 650, 548, 7124, 7}, //index 30 { 722, 606, 7878, 8}, //index 31 //11n GF SIMO { 65, 54, 702, 1}, //index 32 { 130, 108, 1404, 1}, //index 33 { 195, 161, 2093, 2}, //index 34 { 260, 217, 2821, 3}, //index 35 { 390, 326, 4238, 4}, //index 36 { 520, 435, 5655, 6}, //index 37 { 585, 492, 6396, 6}, //index 38 { 650, 548, 7124, 7}, //index 39 //11n SIMO CB MCS 0 - 7 { 135, 110, 1430, 1}, //index 40 { 270, 223, 2899, 3}, //index 41 { 405, 337, 4381, 4}, //index 42 { 540, 454, 5902, 6}, //index 43 { 810, 679, 8827, 9}, //index 44 { 1080, 909, 11817, 12}, //index 45 { 1215, 1022, 13286, 13}, //index 46 { 1350, 1137, 14781, 15}, //index 47 //11n SIMO CB SGI MCS 0 - 7 { 150, 121, 1573, 2}, //index 48 { 300, 249, 3237, 3}, //index 49 { 450, 378, 4914, 5}, //index 50 { 600, 503, 6539, 7}, //index 51 { 900, 758, 9854, 10}, //index 52 { 1200, 1010, 13130, 13}, //index 53 { 1350, 1137, 14781, 15}, //index 54 { 1500, 1262, 16406, 16}, //index 55 //11n SIMO GF CB MCS 0 - 7 { 135, 110, 1430, 1}, //index 56 { 270, 223, 2899, 3}, //index 57 { 405, 337, 4381, 4}, //index 58 { 540, 454, 5902, 6}, //index 59 { 810, 679, 8827, 9}, //index 60 { 1080, 909, 11817, 12}, //index 61 { 1215, 1022, 13286, 13}, //index 62 { 1350, 1137, 14781, 15}, //index 63 //11AC { 1350, 675, 8775, 9}, //reserved 64 { 1350, 675, 8775, 9}, //reserved 65 { 65, 45, 585, 1}, //index 66 { 130, 91, 1183, 1}, //index 67 { 195, 136, 1768, 2}, //index 68 { 260, 182, 2366, 2}, //index 69 { 390, 273, 3549, 4}, //index 70 { 520, 364, 4732, 5}, //index 71 { 585, 409, 5317, 5}, //index 72 { 650, 455, 5915, 6}, //index 73 { 780, 546, 7098, 7}, //index 74 { 1350, 675, 8775, 9}, //reserved 75 { 1350, 675, 8775, 9}, //reserved 76 { 1350, 675, 8775, 9}, //reserved 77 { 1350, 675, 8775, 9}, //index 78 { 1350, 675, 8775, 9}, //index 79 { 1350, 675, 8775, 9}, //index 80 { 1350, 675, 8775, 9}, //index 81 { 1350, 675, 8775, 9}, //index 82 { 1350, 675, 8775, 9}, //index 83 { 655, 458, 5954, 6}, //index 84 { 722, 505, 6565, 7}, //index 85 { 866, 606, 7878, 8}, //index 86 { 1350, 675, 8775, 9}, //reserved 87 { 1350, 675, 8775, 9}, //reserved 88 { 1350, 675, 8775, 9}, //reserved 89 { 135, 94, 1222, 1}, //index 90 { 270, 189, 2457, 2}, //index 91 { 405, 283, 3679, 4}, //index 92 { 540, 378, 4914, 5}, //index 93 { 810, 567, 7371, 7}, //index 94 { 1080, 756, 9828, 10}, //index 95 { 1215, 850, 11050, 11}, //index 96 { 1350, 675, 8775, 9}, //index 97 { 1350, 675, 8775, 9}, //index 98 { 1620, 810, 10530, 11}, //index 99 { 1800, 900, 11700, 12}, //index 100 { 1350, 675, 8775, 9}, //reserved 101 { 1350, 675, 8775, 9}, //index 102 { 1350, 675, 8775, 9}, //index 103 { 1350, 675, 8775, 9}, //index 104 { 1350, 675, 8775, 9}, //index 105 { 1350, 675, 8775, 9}, //index 106 { 1200, 840, 10920, 11}, //index 107 { 1350, 675, 8775, 9}, //index 108 { 1500, 750, 9750, 10}, //index 109 { 1350, 675, 8775, 9}, //index 110 { 1800, 900, 11700, 12}, //index 111 { 2000, 1000, 13000, 13}, //index 112 { 1350, 675, 8775, 9}, //index 113 { 292, 204, 2652, 3}, //index 114 { 585, 409, 5317, 5}, //index 115 { 877, 613, 7969, 8}, //index 116 { 1170, 819, 10647, 11}, //index 117 { 1755, 877, 11401, 11}, //index 118 { 2340, 1170, 15210, 15}, //index 119 { 2632, 1316, 17108, 17}, //index 120 { 2925, 1462, 19006, 19}, //index 121 { 1350, 675, 8775, 9}, //index 122 { 3510, 1755, 22815, 23}, //index 123 { 3900, 1950, 25350, 25}, //index 124 { 1350, 675, 8775, 9}, //reserved 125 { 1350, 675, 8775, 9}, //index 126 { 1350, 675, 8775, 9}, //index 127 { 1350, 675, 8775, 9}, //index 128 { 1350, 675, 8775, 9}, //index 129 { 1350, 675, 8775, 9}, //index 130 { 1350, 675, 8775, 9}, //index 131 { 2925, 1462, 19006, 19}, //index 132 { 3250, 1625, 21125, 21}, //index 133 { 1350, 675, 8775, 9}, //index 134 { 3900, 1950, 25350, 25}, //index 135 { 4333, 2166, 28158, 28} //index 136 }; /*---------------------------------------------------------------------------- * Static Variable Definitions * -------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- * Static Function Declarations and Definitions * -------------------------------------------------------------------------*/ static VOS_STATUS WLANTL_GetEtherType ( v_U8_t * aucBDHeader, vos_pkt_t * vosDataBuff, v_U8_t ucMPDUHLen, v_U16_t * usEtherType ); /*---------------------------------------------------------------------------- * Externalized Function Definitions * -------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- * Function Declarations and Documentation * -------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_FreeClientMemory DESCRIPTION It frees up the memory allocated to all the STA clients in TLCB block Can be called inside Close, Stop or when some FAULT occurs DEPENDENCIES PARAMETERS IN pClientSTA: Pointer to the global client pointer array RETURN VALUE SIDE EFFECTS ============================================================================*/ void WLANTL_FreeClientMemory (WLANTL_STAClientType* pClientSTA[WLAN_MAX_STA_COUNT]) { v_U32_t i = 0; for(i =0; i < WLAN_MAX_STA_COUNT; i++) { if( NULL != pClientSTA[i] ) { vos_mem_free(pClientSTA[i]); } pClientSTA[i] = NULL; } return; } /*========================================================================== FUNCTION WLANTL_Open DESCRIPTION Called by HDD at driver initialization. TL will initialize all its internal resources and will wait for the call to start to register with the other modules. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pTLConfig: TL Configuration RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Open ( v_PVOID_t pvosGCtx, WLANTL_ConfigInfoType* pTLConfig ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucIndex; tHalHandle smeContext; v_U32_t i = 0; #if defined WLAN_FEATURE_NEIGHBOR_ROAMING VOS_STATUS status = VOS_STATUS_SUCCESS; #endif /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ ENTER(); vos_alloc_context( pvosGCtx, VOS_MODULE_ID_TL, (void*)&pTLCb, sizeof(WLANTL_CbType)); pTLCb = VOS_GET_TL_CB(pvosGCtx); if (( NULL == pTLCb ) || ( NULL == pTLConfig ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL: Invalid input pointer on WLANTL_Open TL %pK Config %pK", pTLCb, pTLConfig )); return VOS_STATUS_E_FAULT; } /* Set the default log level to VOS_TRACE_LEVEL_ERROR */ vos_trace_setLevel(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR); smeContext = vos_get_context(VOS_MODULE_ID_SME, pvosGCtx); if ( NULL == smeContext ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid smeContext", __func__)); return VOS_STATUS_E_FAULT; } /* Zero out the memory so we are OK, when CleanCB is called.*/ vos_mem_zero((v_VOID_t *)pTLCb, sizeof(WLANTL_CbType)); /*------------------------------------------------------------------------ Clean up TL control block, initialize all values ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_Open")); for ( i =0; iatlSTAClients[i] = vos_mem_malloc(sizeof(WLANTL_STAClientType)); /* Allocating memory for LEGACY STA COUNT so as to avoid regression issues. */ if ( NULL == pTLCb->atlSTAClients[i] ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: StaClient allocation failed")); WLANTL_FreeClientMemory(pTLCb->atlSTAClients); vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb); return VOS_STATUS_E_FAULT; } vos_mem_zero((v_VOID_t *) pTLCb->atlSTAClients[i], sizeof(WLANTL_STAClientType)); } else { pTLCb->atlSTAClients[i] = NULL; } } pTLCb->reorderBufferPool = vos_mem_vmalloc(sizeof(WLANTL_REORDER_BUFFER_T) * WLANTL_MAX_BA_SESSION); if (NULL == pTLCb->reorderBufferPool) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Reorder buffer allocation failed")); WLANTL_FreeClientMemory(pTLCb->atlSTAClients); vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb); return VOS_STATUS_E_FAULT; } vos_mem_zero((v_VOID_t *)pTLCb->reorderBufferPool, sizeof(WLANTL_REORDER_BUFFER_T) * WLANTL_MAX_BA_SESSION); WLANTL_CleanCB(pTLCb, 0 /*do not empty*/); for ( ucIndex = 0; ucIndex < WLANTL_NUM_TX_QUEUES ; ucIndex++) { pTLCb->tlConfigInfo.ucAcWeights[ucIndex] = pTLConfig->ucAcWeights[ucIndex]; } for ( ucIndex = 0; ucIndex < WLANTL_MAX_AC ; ucIndex++) { pTLCb->tlConfigInfo.ucReorderAgingTime[ucIndex] = pTLConfig->ucReorderAgingTime[ucIndex]; } // scheduling init to be the last one of previous round pTLCb->uCurServedAC = WLANTL_AC_VO; pTLCb->ucCurLeftWeight = pTLCb->tlConfigInfo.ucAcWeights[pTLCb->uCurServedAC]; pTLCb->ucCurrentSTA = WLAN_MAX_STA_COUNT-1; vos_timer_init(&pTLCb->tx_frames_timer, VOS_TIMER_TYPE_SW, WLANTL_SampleTx, (void *)pTLCb); #if 0 //flow control field init vos_mem_zero(&pTLCb->tlFCInfo, sizeof(tFcTxParams_type)); //bit 0: set (Bd/pdu count) bit 1: set (request station PS change notification) pTLCb->tlFCInfo.fcConfig = 0x1; #endif pTLCb->vosTxFCBuf = NULL; pTLCb->tlConfigInfo.uMinFramesProcThres = pTLConfig->uMinFramesProcThres; #ifdef FEATURE_WLAN_TDLS pTLCb->ucTdlsPeerCount = 0; #endif pTLCb->tlConfigInfo.uDelayedTriggerFrmInt = pTLConfig->uDelayedTriggerFrmInt; pTLCb->tlConfigInfo.ucIsReplayCheck = pTLConfig->ucIsReplayCheck; /*------------------------------------------------------------------------ Allocate internal resources ------------------------------------------------------------------------*/ vos_pkt_get_packet(&pTLCb->vosDummyBuf, VOS_PKT_TYPE_RX_RAW, 1, 1, 1/*true*/,NULL, NULL); WLANTL_InitBAReorderBuffer(pvosGCtx); #if defined WLAN_FEATURE_NEIGHBOR_ROAMING /* Initialize Handoff support modue * RSSI measure and Traffic state monitoring */ status = WLANTL_HSInit(pvosGCtx); if(!VOS_IS_STATUS_SUCCESS(status)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Handoff support module init fail")); WLANTL_FreeClientMemory(pTLCb->atlSTAClients); vos_mem_vfree(pTLCb->reorderBufferPool); vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb); return status; } #endif #ifdef WLAN_FEATURE_RMC status = WLANTL_RmcInit(pvosGCtx); if (!VOS_IS_STATUS_SUCCESS(status)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "RMC module init fail")); return status; } #endif pTLCb->isBMPS = VOS_FALSE; pmcRegisterDeviceStateUpdateInd( smeContext, WLANTL_PowerStateChangedCB, pvosGCtx ); return VOS_STATUS_SUCCESS; }/* WLANTL_Open */ /*========================================================================== FUNCTION WLANTL_Start DESCRIPTION Called by HDD as part of the overall start procedure. TL will use this call to register with BAL as a transport layer entity. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other codes can be returned as a result of a BAL failure; see BAL API for more info SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Start ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; v_U32_t uResCount = WDA_TLI_MIN_RES_DATA; VOS_STATUS vosStatus; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ ENTER(); pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_Start")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Register with WDA as transport layer client Request resources for tx from bus ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLAN TL:WLANTL_Start")); tlTraceInit(); vosStatus = WDA_DS_Register( pvosGCtx, WLANTL_TxComp, WLANTL_RxFrames, WLANTL_GetFrames, WLANTL_ResourceCB, WDA_TLI_MIN_RES_DATA, pvosGCtx, &uResCount ); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:TL failed to register with BAL/WDA, Err: %d", vosStatus)); return vosStatus; } /* Enable transmission */ vos_atomic_set_U8( &pTLCb->ucTxSuspended, 0); pTLCb->uResCount = uResCount; if (IS_FEATURE_SUPPORTED_BY_FW(SAP_BUFF_ALLOC)) vos_timer_start(&pTLCb->tx_frames_timer, WLANTL_SAMPLE_INTERVAL); return VOS_STATUS_SUCCESS; }/* WLANTL_Start */ /*========================================================================== FUNCTION WLANTL_Stop DESCRIPTION Called by HDD to stop operation in TL, before close. TL will suspend all frame transfer operation and will wait for the close request to clean up its resources. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Stop ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ ENTER(); pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Stop TL and empty Station list ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_Stop")); /* Disable transmission */ vos_atomic_set_U8( &pTLCb->ucTxSuspended, 1); if ( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff ) { vos_pkt_return_packet(pTLCb->tlMgmtFrmClient.vosPendingDataBuff); pTLCb->tlMgmtFrmClient.vosPendingDataBuff = NULL; } if ( NULL != pTLCb->tlBAPClient.vosPendingDataBuff ) { vos_pkt_return_packet(pTLCb->tlBAPClient.vosPendingDataBuff); pTLCb->tlBAPClient.vosPendingDataBuff = NULL; } #if defined WLAN_FEATURE_NEIGHBOR_ROAMING if(VOS_STATUS_SUCCESS != WLANTL_HSStop(pvosGCtx)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Handoff Support module stop fail")); } #endif if (VOS_TIMER_STATE_STOPPED != vos_timer_getCurrentState(&pTLCb->tx_frames_timer)) vos_timer_stop(&pTLCb->tx_frames_timer); /*------------------------------------------------------------------------- Clean client stations -------------------------------------------------------------------------*/ for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT; ucIndex++) { if ( NULL != pTLCb->atlSTAClients[ucIndex] ) { WLANTL_CleanSTA(pTLCb->atlSTAClients[ucIndex], 1 /*empty all queues*/); } } return VOS_STATUS_SUCCESS; }/* WLANTL_Stop */ /*========================================================================== FUNCTION WLANTL_Close DESCRIPTION Called by HDD during general driver close procedure. TL will clean up all the internal resources. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Close ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; tHalHandle smeContext; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ ENTER(); pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Deregister from PMC ------------------------------------------------------------------------*/ smeContext = vos_get_context(VOS_MODULE_ID_SME, pvosGCtx); if ( NULL == smeContext ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid smeContext", __func__)); // continue so that we can cleanup as much as possible } else { pmcDeregisterDeviceStateUpdateInd( smeContext, WLANTL_PowerStateChangedCB ); } #if defined WLAN_FEATURE_NEIGHBOR_ROAMING if(VOS_STATUS_SUCCESS != WLANTL_HSDeInit(pvosGCtx)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Handoff Support module DeInit fail")); } #endif #ifdef WLAN_FEATURE_RMC if(VOS_STATUS_SUCCESS != WLANTL_RmcDeInit(pvosGCtx)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "RMC module DeInit fail")); } #endif if (VOS_TIMER_STATE_RUNNING == vos_timer_getCurrentState(&pTLCb->tx_frames_timer)) { vos_timer_stop(&pTLCb->tx_frames_timer); } if (!VOS_IS_STATUS_SUCCESS(vos_timer_destroy(&pTLCb->tx_frames_timer))) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Cannot deallocate TX frames sample timer", __func__)); } /*------------------------------------------------------------------------ Cleanup TL control block. ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: WLANTL_Close")); WLANTL_CleanCB(pTLCb, 1 /* empty queues/lists/pkts if any*/); WLANTL_FreeClientMemory(pTLCb->atlSTAClients); vos_mem_vfree(pTLCb->reorderBufferPool); /*------------------------------------------------------------------------ Free TL context from VOSS global ------------------------------------------------------------------------*/ vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb); return VOS_STATUS_SUCCESS; }/* WLANTL_Close */ /*---------------------------------------------------------------------------- INTERACTION WITH HDD ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_ConfigureSwFrameTXXlationForAll DESCRIPTION Function to disable/enable frame translation for all association stations. DEPENDENCIES PARAMETERS IN pvosGCtx: VOS context EnableFrameXlation TRUE means enable SW translation for all stations. . RETURN VALUE void. ============================================================================*/ void WLANTL_ConfigureSwFrameTXXlationForAll ( v_PVOID_t pvosGCtx, v_BOOL_t enableFrameXlation ) { v_U8_t ucIndex; /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); WLANTL_STAClientType* pClientSTA = NULL; if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on " "WLANTL_ConfigureSwFrameTXXlationForAll")); return; } TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLANTL_ConfigureSwFrameTXXlationForAll: Configure SW frameXlation %d", enableFrameXlation)); for ( ucIndex = 0; ucIndex < WLAN_MAX_TID; ucIndex++) { pClientSTA = pTLCb->atlSTAClients[ucIndex]; if ( NULL != pClientSTA && 0 != pClientSTA->ucExists ) { #ifdef WLAN_SOFTAP_VSTA_FEATURE // if this station was not allocated resources to perform HW-based // TX frame translation then force SW-based TX frame translation // otherwise use the frame translation supplied by the client if (!WDA_IsHwFrameTxTranslationCapable(pvosGCtx, ucIndex)) { pClientSTA->wSTADesc.ucSwFrameTXXlation = 1; } else #endif pClientSTA->wSTADesc.ucSwFrameTXXlation = enableFrameXlation; } } } /*=========================================================================== FUNCTION WLANTL_StartForwarding DESCRIPTION This function is used to ask serialization through TX thread of the cached frame forwarding (if statation has been registered in the mean while) or flushing (if station has not been registered by the time) In case of forwarding, upper layer is only required to call WLANTL_RegisterSTAClient() and doesn't need to call this function explicitly. TL will handle this inside WLANTL_RegisterSTAClient(). In case of flushing, upper layer is required to call this function explicitly DEPENDENCIES TL must have been initialized before this gets called. PARAMETERS ucSTAId: station id RETURN VALUE The result code associated with performing the operation Please check return values of vos_tx_mq_serialize. SIDE EFFECTS If TL was asked to perform WLANTL_CacheSTAFrame() in WLANTL_RxFrames(), either WLANTL_RegisterSTAClient() or this function must be called within reasonable time. Otherwise, TL will keep cached vos buffer until one of this function is called, and may end up with system buffer exhasution. It's an upper layer's responsibility to call this function in case of flushing ============================================================================*/ VOS_STATUS WLANTL_StartForwarding ( v_U8_t ucSTAId, v_U8_t ucUcastSig, v_U8_t ucBcastSig ) { vos_msg_t sMessage; v_U32_t uData; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Signal the OS to serialize our event */ VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Serializing TL Start Forwarding Cached for control STA %d", ucSTAId ); vos_mem_zero( &sMessage, sizeof(vos_msg_t) ); uData = ucSTAId | (ucUcastSig << 8 ) | (ucBcastSig << 16); sMessage.bodyval = uData; sMessage.type = WLANTL_RX_FWD_CACHED; return vos_rx_mq_serialize(VOS_MQ_ID_TL, &sMessage); } /* WLANTL_StartForwarding() */ /*=========================================================================== FUNCTION WLANTL_EnableCaching DESCRIPTION This function is used to enable caching only when assoc/reassoc req is send. that is cache packets only for such STA ID. DEPENDENCIES TL must have been initialized before this gets called. PARAMETERS staId: station id RETURN VALUE none ============================================================================*/ void WLANTL_EnableCaching(v_U8_t staId) { v_PVOID_t pvosGCtx= vos_get_global_context(VOS_MODULE_ID_TL,NULL); WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on " "WLANTL_EnableCaching")); return; } pTLCb->atlSTAClients[staId]->enableCaching = 1; } /*=========================================================================== FUNCTION WLANTL_AssocFailed DESCRIPTION This function is used by PE to notify TL that cache needs to flushed' when association is not successfully completed Internally, TL post a message to TX_Thread to serialize the request to keep lock-free mechanism. DEPENDENCIES TL must have been initialized before this gets called. PARAMETERS ucSTAId: station id RETURN VALUE none SIDE EFFECTS There may be race condition that PE call this API and send another association request immediately with same staId before TX_thread can process the message. To avoid this, we might need PE to wait for TX_thread process the message, but this is not currently implemented. ============================================================================*/ void WLANTL_AssocFailed(v_U8_t staId) { // flushing frames and forwarding frames uses the same message // the only difference is what happens when the message is processed // if the STA exist, the frames will be forwarded // and if it doesn't exist, the frames will be flushed // in this case we know it won't exist so the DPU index signature values don't matter MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_ASSOC_FAILED, staId, 0)); if(!VOS_IS_STATUS_SUCCESS(WLANTL_StartForwarding(staId,0,0))) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s fails to start forwarding (staId %d)", __func__, staId); } } /*=========================================================================== FUNCTION WLANTL_Finish_ULA DESCRIPTION This function is used by HDD to notify TL to finish Upper layer authentication incase the last EAPOL packet is pending in the TL queue. To avoid the race condition between sme set key and the last EAPOL packet the HDD module calls this function just before calling the sme_RoamSetKey. DEPENDENCIES TL must have been initialized before this gets called. PARAMETERS callbackRoutine: HDD Callback function. callbackContext : HDD userdata context. RETURN VALUE VOS_STATUS_SUCCESS/VOS_STATUS_FAILURE SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Finish_ULA( void (*callbackRoutine) (void *callbackContext), void *callbackContext) { return WDA_DS_FinishULA( callbackRoutine, callbackContext); } /*=========================================================================== FUNCTION WLANTL_RegisterSTAClient DESCRIPTION This function is used by HDD to register as a client for data services with TL. HDD will call this API for each new station that it adds, thus having the flexibility of registering different callback for each STA it services. DEPENDENCIES TL must have been initialized before this gets called. Restriction: Main thread will have higher priority that Tx and Rx threads thus guaranteeing that a station will be added before any data can be received for it. (This enables TL to be lock free) PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pfnStARx: function pointer to the receive packet handler from HDD pfnSTATxComp: function pointer to the transmit complete confirmation handler from HDD pfnSTAFetchPkt: function pointer to the packet retrieval routine in HDD wSTADescType: STA Descriptor, contains information related to the new added STA RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was already registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RegisterSTAClient ( v_PVOID_t pvosGCtx, WLANTL_STARxCBType pfnSTARx, WLANTL_TxCompCBType pfnSTATxComp, WLANTL_STAFetchPktCBType pfnSTAFetchPkt, WLAN_STADescType* pwSTADescType, v_S7_t rssi ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; v_U8_t ucTid = 0;/*Local variable to clear previous replay counters of STA on all TIDs*/ v_U32_t istoggleArpEnb = 0; tpAniSirGlobal pMac; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ ENTER(); if (( NULL == pwSTADescType ) || ( NULL == pfnSTARx ) || ( NULL == pfnSTAFetchPkt )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RegisterSTAClient")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( pwSTADescType->ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_RegisterSTAClient")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_RegisterSTAClient")); return VOS_STATUS_E_FAULT; } //Code for checking and allocating memory for new STA if ( NULL == pTLCb->atlSTAClients[pwSTADescType->ucSTAId] ){ pTLCb->atlSTAClients[pwSTADescType->ucSTAId] = vos_mem_malloc(sizeof(WLANTL_STAClientType)); if ( NULL == pTLCb->atlSTAClients[pwSTADescType->ucSTAId] ){ TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: STA Client memory allocation failed in WLANTL_RegisterSTAClient")); return VOS_STATUS_E_FAILURE; } TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: STA Client memory allocation in WLANTL_RegisterSTAClient")); vos_mem_zero((v_VOID_t *) pTLCb->atlSTAClients[pwSTADescType->ucSTAId],sizeof(WLANTL_STAClientType)); } //Assigning the pointer to local variable for easy access in future pClientSTA = pTLCb->atlSTAClients[pwSTADescType->ucSTAId]; if ( 0 != pClientSTA->ucExists ) { pClientSTA->ucExists++; TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was already registered on WLANTL_RegisterSTAClient")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Register station with TL ------------------------------------------------------------------------*/ MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_REGISTER_STA_CLIENT, pwSTADescType->ucSTAId, (unsigned ) (*(pwSTADescType->vSTAMACAddress.bytes+2)<<24 | *(pwSTADescType->vSTAMACAddress.bytes+3)<<16 | *(pwSTADescType->vSTAMACAddress.bytes+4)<<8 | *(pwSTADescType->vSTAMACAddress.bytes+5)))); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering STA Client ID: %d", pwSTADescType->ucSTAId )); pClientSTA->pfnSTARx = pfnSTARx; pClientSTA->pfnSTAFetchPkt = pfnSTAFetchPkt; /* Only register if different from NULL - TL default Tx Comp Cb will release the vos packet */ if ( NULL != pfnSTATxComp ) { pClientSTA->pfnSTATxComp = pfnSTATxComp; } pClientSTA->tlState = WLANTL_STA_INIT; pClientSTA->tlPri = WLANTL_STA_PRI_NORMAL; pClientSTA->wSTADesc.ucSTAId = pwSTADescType->ucSTAId; pClientSTA->ptkInstalled = 0; pClientSTA->disassoc_progress = VOS_FALSE; pMac = vos_get_context(VOS_MODULE_ID_PE, pvosGCtx); if ( NULL != pMac ) { wlan_cfgGetInt(pMac, WNI_CFG_TOGGLE_ARP_BDRATES, &istoggleArpEnb); } pClientSTA->arpRate = istoggleArpEnb ? ENABLE_ARP_TOGGLE : DISABLE_ARP_TOGGLE; pClientSTA->arpOnWQ5 = istoggleArpEnb == SEND_ARP_ON_WQ5; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering STA Client ID: %d with UC %d and BC %d toggleArp :%hhu", pwSTADescType->ucSTAId, pwSTADescType->ucUcastSig, pwSTADescType->ucBcastSig, pClientSTA->arpRate)); pClientSTA->wSTADesc.wSTAType = pwSTADescType->wSTAType; pClientSTA->wSTADesc.ucQosEnabled = pwSTADescType->ucQosEnabled; pClientSTA->wSTADesc.ucAddRmvLLC = pwSTADescType->ucAddRmvLLC; pClientSTA->wSTADesc.ucProtectedFrame = pwSTADescType->ucProtectedFrame; #ifdef FEATURE_WLAN_ESE pClientSTA->wSTADesc.ucIsEseSta = pwSTADescType->ucIsEseSta; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering STA Client ID: %d QoS %d Add LLC %d ProtFrame %d EseSta %d", pwSTADescType->ucSTAId, pwSTADescType->ucQosEnabled, pwSTADescType->ucAddRmvLLC, pwSTADescType->ucProtectedFrame, pwSTADescType->ucIsEseSta)); #else TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering STA Client ID: %d QoS %d Add LLC %d ProtFrame %d", pwSTADescType->ucSTAId, pwSTADescType->ucQosEnabled, pwSTADescType->ucAddRmvLLC, pwSTADescType->ucProtectedFrame)); #endif //FEATURE_WLAN_ESE #ifdef WLAN_SOFTAP_VSTA_FEATURE // if this station was not allocated resources to perform HW-based // TX frame translation then force SW-based TX frame translation // otherwise use the frame translation supplied by the client if (!WDA_IsHwFrameTxTranslationCapable(pvosGCtx, pwSTADescType->ucSTAId) || ( WLAN_STA_BT_AMP == pwSTADescType->wSTAType)) { pwSTADescType->ucSwFrameTXXlation = 1; } #endif pClientSTA->wSTADesc.ucSwFrameTXXlation = pwSTADescType->ucSwFrameTXXlation; pClientSTA->wSTADesc.ucSwFrameRXXlation = pwSTADescType->ucSwFrameRXXlation; #ifdef FEATURE_WLAN_WAPI pClientSTA->wSTADesc.ucIsWapiSta = pwSTADescType->ucIsWapiSta; #endif /* FEATURE_WLAN_WAPI */ vos_copy_macaddr( &pClientSTA->wSTADesc.vSTAMACAddress, &pwSTADescType->vSTAMACAddress); vos_copy_macaddr( &pClientSTA->wSTADesc.vBSSIDforIBSS, &pwSTADescType->vBSSIDforIBSS); vos_copy_macaddr( &pClientSTA->wSTADesc.vSelfMACAddress, &pwSTADescType->vSelfMACAddress); /* In volans release L replay check is done at TL */ if (pTLCb->tlConfigInfo.ucIsReplayCheck) pClientSTA->ucIsReplayCheckValid = pwSTADescType->ucIsReplayCheckValid; pClientSTA->ulTotalReplayPacketsDetected = 0; /*Clear replay counters of the STA on all TIDs*/ for(ucTid = 0; ucTid < WLANTL_MAX_TID ; ucTid++) { pClientSTA->ullReplayCounter[ucTid] = 0; } /*-------------------------------------------------------------------- Set the AC for the registered station to the highest priority AC Even if this AC is not supported by the station, correction will be made in the main TL loop after the supported mask is properly updated in the pending packets call --------------------------------------------------------------------*/ pClientSTA->ucCurrentAC = WLANTL_AC_HIGH_PRIO; pClientSTA->ucCurrentWeight = 0; pClientSTA->ucServicedAC = WLANTL_AC_BK; pClientSTA->ucEapolPktPending = 0; vos_mem_zero( pClientSTA->aucACMask, sizeof(pClientSTA->aucACMask)); vos_mem_zero( &pClientSTA->wUAPSDInfo, sizeof(pClientSTA->wUAPSDInfo)); /*-------------------------------------------------------------------- Reordering info and AMSDU de-aggregation --------------------------------------------------------------------*/ vos_mem_zero( pClientSTA->atlBAReorderInfo, sizeof(pClientSTA->atlBAReorderInfo[0])* WLAN_MAX_TID); vos_mem_zero( pClientSTA->aucMPDUHeader, WLANTL_MPDU_HEADER_LEN); pClientSTA->ucMPDUHeaderLen = 0; pClientSTA->vosAMSDUChain = NULL; pClientSTA->vosAMSDUChainRoot = NULL; /* Reorder LOCK * During handle normal RX frame within RX thread, * if MC thread try to preempt, ADDBA, DELBA, TIMER * Context should be protected from race */ for (ucTid = 0; ucTid < WLAN_MAX_TID ; ucTid++) { if (!VOS_IS_STATUS_SUCCESS( vos_lock_init(&pClientSTA->atlBAReorderInfo[ucTid].reorderLock))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Lock Init Fail")); return VOS_STATUS_E_FAILURE; } } /*-------------------------------------------------------------------- Stats info --------------------------------------------------------------------*/ vos_mem_zero( pClientSTA->auRxCount, sizeof(pClientSTA->auRxCount[0])* WLAN_MAX_TID); vos_mem_zero( pClientSTA->auTxCount, sizeof(pClientSTA->auRxCount[0])* WLAN_MAX_TID); /* Initial RSSI is always reported as zero because TL doesnt have enough data to calculate RSSI. So to avoid reporting zero, we are initializing RSSI with RSSI saved in BssDescription during scanning. */ pClientSTA->rssiAvg = rssi; pClientSTA->rssiAvgBmps = rssi; #ifdef FEATURE_WLAN_TDLS if(WLAN_STA_TDLS == pClientSTA->wSTADesc.wSTAType) { /* If client is TDLS, use TDLS specific alpha */ pClientSTA->rssiAlpha = WLANTL_HO_TDLS_ALPHA; } else { pClientSTA->rssiAlpha = WLANTL_HO_DEFAULT_ALPHA; } #else pClientSTA->rssiAlpha = WLANTL_HO_DEFAULT_ALPHA; #endif /* FEATURE_WLAN_TDLS */ #ifdef WLAN_FEATURE_LINK_LAYER_STATS pClientSTA->rssiDataAlpha = WLANTL_HO_DEFAULT_ALPHA; pClientSTA->interfaceStats.accessCategoryStats[0].ac = WLANTL_AC_BK; pClientSTA->interfaceStats.accessCategoryStats[1].ac = WLANTL_AC_BE; pClientSTA->interfaceStats.accessCategoryStats[2].ac = WLANTL_AC_VI; pClientSTA->interfaceStats.accessCategoryStats[3].ac = WLANTL_AC_VO; #endif /*Tx not suspended and station fully registered*/ vos_atomic_set_U8( &pClientSTA->ucTxSuspended, 0); /* Used until multiple station support will be added*/ pTLCb->ucRegisteredStaId = pwSTADescType->ucSTAId; /* Save the BAP station ID for future usage */ if ( WLAN_STA_BT_AMP == pwSTADescType->wSTAType ) { pTLCb->tlBAPClient.ucBAPSTAId = pwSTADescType->ucSTAId; } /*------------------------------------------------------------------------ Statistics info -----------------------------------------------------------------------*/ memset(&pClientSTA->trafficStatistics, 0, sizeof(WLANTL_TRANSFER_STA_TYPE)); /*------------------------------------------------------------------------ Start with the state suggested by client caller -----------------------------------------------------------------------*/ pClientSTA->tlState = pwSTADescType->ucInitState; /*----------------------------------------------------------------------- After all the init is complete we can mark the existance flag ----------------------------------------------------------------------*/ pClientSTA->ucExists++; //flow control fields init pClientSTA->ucLwmModeEnabled = FALSE; pClientSTA->ucLwmEventReported = FALSE; pClientSTA->bmuMemConsumed = 0; pClientSTA->uIngress_length = 0; pClientSTA->uBuffThresholdMax = WLANTL_STA_BMU_THRESHOLD_MAX; pClientSTA->uLwmThreshold = WLANTL_STA_BMU_THRESHOLD_MAX / 3; //@@@ HDDSOFTAP does not queue unregistered packet for now if ( WLAN_STA_SOFTAP != pwSTADescType->wSTAType ) { /*------------------------------------------------------------------------ Forward received frames while STA was not yet registered - ----------------------------------------------------------------------*/ if(!VOS_IS_STATUS_SUCCESS(WLANTL_StartForwarding( pwSTADescType->ucSTAId, pwSTADescType->ucUcastSig, pwSTADescType->ucBcastSig))) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s fails to start forwarding", __func__); } #ifdef FEATURE_WLAN_TDLS if( WLAN_STA_TDLS == pwSTADescType->wSTAType ) pTLCb->ucTdlsPeerCount++; #endif } #ifdef WLAN_FEATURE_RMC vos_lock_init(&pClientSTA->mcLock); #endif /* WLAN_FEATURE_RMC */ return VOS_STATUS_SUCCESS; }/* WLANTL_RegisterSTAClient */ /*=========================================================================== FUNCTION WLANTL_ClearSTAClient DESCRIPTION HDD will call this API when it no longer needs data services for the particular station. DEPENDENCIES A station must have been registered before the clear registration is called. PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier for the STA to be cleared RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ClearSTAClient ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ ENTER(); /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_ClearSTAClient")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ClearSTAClient")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_ClearSTAClient")); /* Clean packets cached for the STA */ WLANTL_StartForwarding(ucSTAId,0,0); return VOS_STATUS_E_EXISTS; } /* Delete BA sessions on all TID's */ for (ucIndex = 0; ucIndex < WLAN_MAX_TID ; ucIndex++) { WLANTL_BaSessionDel(pvosGCtx, ucSTAId, ucIndex); vos_lock_destroy(&pTLCb->atlSTAClients[ucSTAId]->atlBAReorderInfo[ucIndex].reorderLock); } #ifdef FEATURE_WLAN_TDLS /* decrement ucTdlsPeerCount only if it is non-zero */ if(WLAN_STA_TDLS == pTLCb->atlSTAClients[ucSTAId]->wSTADesc.wSTAType && pTLCb->ucTdlsPeerCount) pTLCb->ucTdlsPeerCount--; #endif /*------------------------------------------------------------------------ Clear station ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Clearing STA Client ID: %d", ucSTAId )); WLANTL_CleanSTA(pTLCb->atlSTAClients[ucSTAId], 1 /*empty packets*/); #ifdef WLAN_FEATURE_RMC /*-------------------------------------------------------------------- Delete multicast entries for duplicate detection --------------------------------------------------------------------*/ WLANTL_McastDeleteAllEntries(pTLCb->atlSTAClients[ucSTAId]); vos_lock_destroy(&pTLCb->atlSTAClients[ucSTAId]->mcLock); #endif /* WLAN_FEATURE_RMC */ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Clearing STA Reset History RSSI and Region number")); pTLCb->hoSupport.currentHOState.historyRSSI = 0; pTLCb->hoSupport.currentHOState.regionNumber = 0; return VOS_STATUS_SUCCESS; }/* WLANTL_ClearSTAClient */ /*=========================================================================== FUNCTION WLANTL_ChangeSTAState DESCRIPTION HDD will make this notification whenever a change occurs in the connectivity state of a particular STA. DEPENDENCIES A station must have been registered before the change state can be called. RESTRICTION: A station is being notified as authenticated before the keys are installed in HW. This way if a frame is received before the keys are installed DPU will drop that frame. Main thread has higher priority that Tx and Rx threads thus guaranteeing the following: - a station will be in assoc state in TL before TL receives any data for it PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier for the STA that is pending transmission tlSTAState: the new state of the connection to the given station RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ChangeSTAState ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_STAStateType tlSTAState ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( tlSTAState >= WLANTL_STA_MAX_STATE ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_ChangeSTAState")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_ChangeSTAState")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Change STA state No need to lock this operation, see restrictions above ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Changing state for STA Client ID: %d from %d to %d", ucSTAId, pTLCb->atlSTAClients[ucSTAId]->tlState, tlSTAState)); MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_STA_STATE, ucSTAId,tlSTAState )); pTLCb->atlSTAClients[ucSTAId]->tlState = tlSTAState; return VOS_STATUS_SUCCESS; }/* WLANTL_ChangeSTAState */ /*=========================================================================== FUNCTION WLANTL_UpdateTdlsSTAClient DESCRIPTION HDD will call this API when ENABLE_LINK happens and HDD want to register QoS or other params for TDLS peers. DEPENDENCIES A station must have been registered before the WMM/QOS registration is called. PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context wSTADescType: STA Descriptor, contains information related to the new added STA RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_UpdateTdlsSTAClient ( v_PVOID_t pvosGCtx, WLAN_STADescType* pwSTADescType ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb || ( WLAN_MAX_STA_COUNT <= pwSTADescType->ucSTAId)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_UpdateTdlsSTAClient")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[pwSTADescType->ucSTAId]; if ((NULL == pClientSTA) || 0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station not exists")); return VOS_STATUS_E_FAILURE; } pClientSTA->wSTADesc.ucQosEnabled = pwSTADescType->ucQosEnabled; TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: %s: ucQosEnabled of pwSTADescType: %d" "pClientSTA->wSTADesc: %d", __func__, pwSTADescType->ucQosEnabled, pClientSTA->wSTADesc.ucQosEnabled)); return VOS_STATUS_SUCCESS; } VOS_STATUS WLANTL_SetMonRxCbk(v_PVOID_t pvosGCtx, WLANTL_MonRxCBType pfnMonRx) { WLANTL_CbType* pTLCb = NULL ; pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_RegisterSTAClient")); return VOS_STATUS_E_FAULT; } pTLCb->pfnMonRx = pfnMonRx; return VOS_STATUS_SUCCESS; } void WLANTL_SetIsConversionReq(v_PVOID_t pvosGCtx, v_BOOL_t isConversionReq) { WLANTL_CbType* pTLCb = NULL ; pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_RegisterSTAClient")); return; } pTLCb->isConversionReq = isConversionReq; return; } /*=========================================================================== FUNCTION WLANTL_STAPtkInstalled DESCRIPTION HDD will make this notification whenever PTK is installed for the STA DEPENDENCIES A station must have been registered before the change state can be called. PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier for the STA for which Pairwise key is installed RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STAPtkInstalled ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Invalid TL pointer from pvosGCtx"))); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Client Memory was not allocated"))); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Station was not previously registered"))); return VOS_STATUS_E_EXISTS; } pTLCb->atlSTAClients[ucSTAId]->ptkInstalled = 1; return VOS_STATUS_SUCCESS; }/* WLANTL_STAPtkInstalled */ /*=========================================================================== FUNCTION WLANTL_GetSTAState DESCRIPTION Returns connectivity state of a particular STA. DEPENDENCIES A station must have been registered before its state can be retrieved. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station OUT ptlSTAState: the current state of the connection to the given station RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetSTAState ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_STAStateType *ptlSTAState ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == ptlSTAState ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetSTAState")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_GetSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetSTAState")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Station was not previously registered on WLANTL_GetSTAState")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Get STA state ------------------------------------------------------------------------*/ *ptlSTAState = pTLCb->atlSTAClients[ucSTAId]->tlState; return VOS_STATUS_SUCCESS; }/* WLANTL_GetSTAState */ /*========================================================================== FUNCTION WLANTL_UpdateSTABssIdforIBSS DESCRIPTION HDD will call this API to update the BSSID for this Station. DEPENDENCIES The HDD Should registered the staID with TL before calling this function. PARAMETERS IN pvosGCtx: Pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context IN ucSTAId The Station ID for Bssid to be updated IN pBssid BSSID to be updated RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_UpdateSTABssIdforIBSS ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U8_t *pBssid ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested %s", __func__)); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx %s", __func__)); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Station was not previously registered %s", __func__)); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Update the IBSS BSSID ------------------------------------------------------------------------*/ vos_mem_copy( &pTLCb->atlSTAClients[ucSTAId]->wSTADesc.vBSSIDforIBSS, pBssid, sizeof(v_MACADDR_t)); return VOS_STATUS_SUCCESS; } /*=========================================================================== FUNCTION WLANTL_STAPktPending DESCRIPTION HDD will call this API when a packet is pending transmission in its queues. DEPENDENCIES A station must have been registered before the packet pending notification can be sent. RESTRICTION: TL will not count packets for pending notification. HDD is expected to send the notification only when non-empty event gets triggered. Worst case scenario is that TL might end up making a call when Hdds queues are actually empty. PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier for the STA that is pending transmission RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STAPktPending ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_ACEnumType ucAc ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:Packet pending indication for STA: %d AC: %d", ucSTAId, ucAc); /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_STAPktPending")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_STAPktPending")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_STAPktPending")); return VOS_STATUS_E_EXISTS; } /*--------------------------------------------------------------------- Temporary fix to enable TL to fetch packets when multiple peers join an IBSS. To fix CR177301. Needs to go away when the actual fix of going through all STA's in round robin fashion gets merged in from BT AMP branch. --------------------------------------------------------------------*/ pTLCb->ucRegisteredStaId = ucSTAId; if( WLANTL_STA_CONNECTED == pClientSTA->tlState ) { /* EAPOL_HI_PRIORITY : need to find out whether EAPOL is pending before WLANTL_FetchPacket()/WLANTL_TxConn() is called. change STA_AUTHENTICATED != tlState to CONNECTED == tlState to make sure TL is indeed waiting for EAPOL. Just in the case when STA got disconnected shortly after connectection */ pClientSTA->ucEapolPktPending = 1; MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_EAPOL_PKT_PENDING, ucSTAId, ucAc)); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Packet pending indication for STA: %d AC: %d State: %d", ucSTAId, ucAc, pClientSTA->tlState); } /*----------------------------------------------------------------------- Enable this AC in the AC mask in order for TL to start servicing it Set packet pending flag To avoid race condition, serialize the updation of AC and AC mask through WLANTL_TX_STAID_AC_IND message. -----------------------------------------------------------------------*/ pClientSTA->aucACMask[ucAc] = 1; vos_atomic_set_U8( &pClientSTA->ucPktPending, 1); /*------------------------------------------------------------------------ Check if there are enough resources for transmission and tx is not suspended. ------------------------------------------------------------------------*/ if (( pTLCb->uResCount >= WDA_TLI_MIN_RES_DATA ) && ( 0 == pTLCb->ucTxSuspended )) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Issuing Xmit start request to BAL")); WDA_DS_StartXmit(pvosGCtx); } else { /*--------------------------------------------------------------------- No error code is sent because TL will resume tx autonomously if resources become available or tx gets resumed ---------------------------------------------------------------------*/ VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Request to send but condition not met. Res: %d,Suspend: %d", pTLCb->uResCount, pTLCb->ucTxSuspended ); } return VOS_STATUS_SUCCESS; }/* WLANTL_STAPktPending */ /*========================================================================== FUNCTION WLANTL_SetSTAPriority DESCRIPTION TL exposes this API to allow upper layers a rough control over the priority of transmission for a given station when supporting multiple connections. DEPENDENCIES A station must have been registered before the change in priority can be called. PARAMETERS pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier for the STA that has to change priority RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_SetSTAPriority ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_STAPriorityType tlSTAPri ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_SetSTAPriority")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_SetSTAPriority")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_SetSTAPriority")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Re-analize if lock is needed when adding multiple stations ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Changing state for STA Pri ID: %d from %d to %d", ucSTAId, pClientSTA->tlPri, tlSTAPri)); pClientSTA->tlPri = tlSTAPri; return VOS_STATUS_SUCCESS; }/* WLANTL_SetSTAPriority */ /*---------------------------------------------------------------------------- INTERACTION WITH BAP ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_RegisterBAPClient DESCRIPTION Called by SME to register itself as client for non-data BT-AMP packets. DEPENDENCIES TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context pfnTlBAPRxFrm: pointer to the receive processing routine for non-data BT-AMP packets pfnFlushOpCompleteCb: pointer to the call back function, for the Flush operation completion. RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: BAL client was already registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RegisterBAPClient ( v_PVOID_t pvosGCtx, WLANTL_BAPRxCBType pfnTlBAPRxFrm, WLANTL_FlushOpCompCBType pfnFlushOpCompleteCb ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pfnTlBAPRxFrm ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RegisterBAPClient")); return VOS_STATUS_E_INVAL; } if ( NULL == pfnFlushOpCompleteCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid Flush Complete Cb parameter sent on WLANTL_RegisterBAPClient")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_RegisterBAPClient")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Make sure this is the first registration attempt ------------------------------------------------------------------------*/ if ( 0 != pTLCb->tlBAPClient.ucExists ) { pTLCb->tlBAPClient.ucExists++; TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:BAP client was already registered")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Register station with TL ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering BAP Client" )); pTLCb->tlBAPClient.ucExists++; if ( NULL != pfnTlBAPRxFrm ) { pTLCb->tlBAPClient.pfnTlBAPRx = pfnTlBAPRxFrm; } pTLCb->tlBAPClient.pfnFlushOpCompleteCb = pfnFlushOpCompleteCb; pTLCb->tlBAPClient.vosPendingDataBuff = NULL; return VOS_STATUS_SUCCESS; }/* WLANTL_RegisterBAPClient */ /*========================================================================== FUNCTION WLANTL_TxBAPFrm DESCRIPTION BAP calls this when it wants to send a frame to the module DEPENDENCIES BAP must be registered with TL before this function can be called. RESTRICTION: BAP CANNOT push any packets to TL until it did not receive a tx complete from the previous packet, that means BAP sends one packet, wait for tx complete and then sends another one If BAP sends another packet before TL manages to process the previously sent packet call will end in failure PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or BAP's control block can be extracted from its context vosDataBuff: pointer to the vOSS buffer containing the packet to be transmitted pMetaInfo: meta information about the packet pfnTlBAPTxComp: pointer to a transmit complete routine for notifying the result of the operation over the bus RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: BAL client was not yet registered VOS_STATUS_E_BUSY: The previous BT-AMP packet was not yet transmitted VOS_STATUS_SUCCESS: Everything is good :) Other failure messages may be returned from the BD header handling routines, please check apropriate API for more info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_TxBAPFrm ( v_PVOID_t pvosGCtx, vos_pkt_t* vosDataBuff, WLANTL_MetaInfoType* pMetaInfo, WLANTL_TxCompCBType pfnTlBAPTxComp ) { WLANTL_CbType* pTLCb = NULL; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_MACADDR_t vDestMacAddr; v_U16_t usPktLen; v_U8_t ucStaId = 0; v_U8_t extraHeadSpace = 0; v_U8_t ucWDSEnabled = 0; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_TxBAPFrm")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Ensure that BAP client was registered previously ------------------------------------------------------------------------*/ if (( 0 == pTLCb->tlBAPClient.ucExists ) || ( WLANTL_STA_ID_INVALID(pTLCb->tlBAPClient.ucBAPSTAId) )) { pTLCb->tlBAPClient.ucExists++; TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:BAP client not register on WLANTL_TxBAPFrm")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Check if any BT-AMP Frm is pending ------------------------------------------------------------------------*/ if ( NULL != pTLCb->tlBAPClient.vosPendingDataBuff ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:BT-AMP Frame already pending tx in TL on WLANTL_TxBAPFrm")); return VOS_STATUS_E_BUSY; } /*------------------------------------------------------------------------ Save buffer and notify BAL; no lock is needed if the above restriction is met Save the tx complete fnct pointer as tl specific data in the vos buffer ------------------------------------------------------------------------*/ /*------------------------------------------------------------------------ Translate 802.3 frame to 802.11 ------------------------------------------------------------------------*/ ucStaId = pTLCb->tlBAPClient.ucBAPSTAId; if ( NULL == pTLCb->atlSTAClients[ucStaId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if (( 0 == pMetaInfo->ucDisableFrmXtl ) && ( 0 != pTLCb->atlSTAClients[ucStaId]->wSTADesc.ucSwFrameTXXlation )) { vosStatus = WLANTL_Translate8023To80211Header( vosDataBuff, &vosStatus, pTLCb, &ucStaId, pMetaInfo, &ucWDSEnabled, &extraHeadSpace); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Error when translating header WLANTL_TxBAPFrm")); return vosStatus; } pMetaInfo->ucDisableFrmXtl = 1; } /*------------------------------------------------------------------------- Call HAL to fill BD header -------------------------------------------------------------------------*/ /* Adding Type, SubType which was missing for EAPOL from BAP */ pMetaInfo->ucType |= (WLANTL_80211_DATA_TYPE << 4); pMetaInfo->ucType |= (WLANTL_80211_DATA_QOS_SUBTYPE); vosStatus = WDA_DS_BuildTxPacketInfo( pvosGCtx, vosDataBuff , &vDestMacAddr, pMetaInfo->ucDisableFrmXtl, &usPktLen, pTLCb->atlSTAClients[ucStaId]->wSTADesc.ucQosEnabled, ucWDSEnabled, extraHeadSpace, pMetaInfo->ucType, &pTLCb->atlSTAClients[ucStaId]->wSTADesc.vSelfMACAddress, pMetaInfo->ucTID, 0 /* No ACK */, pMetaInfo->usTimeStamp, pMetaInfo->ucIsEapol || pMetaInfo->ucIsWai, pMetaInfo->ucIsArp, pMetaInfo->ucUP, pMetaInfo->ucTxBdToken); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while building TX header %d", vosStatus)); return vosStatus; } if ( NULL != pfnTlBAPTxComp ) { vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)pfnTlBAPTxComp); } else { vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)WLANTL_TxCompDefaultCb); } vos_atomic_set( (uintptr_t*)&pTLCb->tlBAPClient.vosPendingDataBuff, (uintptr_t)vosDataBuff); /*------------------------------------------------------------------------ Check if thre are enough resources for transmission and tx is not suspended. ------------------------------------------------------------------------*/ if (( pTLCb->uResCount >= WDA_TLI_MIN_RES_BAP ) && ( 0 == pTLCb->ucTxSuspended )) { WDA_DS_StartXmit(pvosGCtx); } else { /*--------------------------------------------------------------------- No error code is sent because TL will resume tx autonomously if resources become available or tx gets resumed ---------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Request to send from BAP but condition not met.Res: %d," "Suspend: %d", pTLCb->uResCount, pTLCb->ucTxSuspended )); } return VOS_STATUS_SUCCESS; }/* WLANTL_TxBAPFrm */ /*---------------------------------------------------------------------------- INTERACTION WITH SME ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_GetRssi DESCRIPTION TL will extract the RSSI information from every data packet from the ongoing traffic and will store it. It will provide the result to SME upon request. DEPENDENCIES WARNING: the read and write of this value will not be protected by locks, therefore the information obtained after a read might not always be consistent. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context ucSTAId: station identifier for the requested value OUT puRssi: the average value of the RSSI RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: STA was not yet registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetRssi ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_S7_t* pRssi ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pRssi ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetRssi")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_GetRssi")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetRssi")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_GetRssi")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Copy will not be locked; please read restriction ------------------------------------------------------------------------*/ if(pTLCb->isBMPS || IS_ACTIVEMODE_OFFLOAD_FEATURE_ENABLE) { *pRssi = pClientSTA->rssiAvgBmps; /* Check If RSSI is zero because we are reading rssAvgBmps updated by HAL in previous GetStatsRequest. It may be updated as zero by Hal because EnterBmps might not have happend by that time. Hence reading the most recent Rssi calcluated by TL*/ if(0 == *pRssi) { *pRssi = pClientSTA->rssiAvg; } } else { *pRssi = pClientSTA->rssiAvg; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_GetRssi for STA: %d RSSI: %d%s", ucSTAId, *pRssi, pTLCb->isBMPS ? " in BMPS" : "")); return VOS_STATUS_SUCCESS; }/* WLANTL_GetRssi */ /*========================================================================== FUNCTION WLANTL_GetSnr DESCRIPTION TL will extract the SNR information from every data packet from the ongoing traffic and will store it. It will provide the result to SME upon request. DEPENDENCIES WARNING: the read and write of this value will not be protected by locks, therefore the information obtained after a read might not always be consistent. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context ucSTAId: station identifier for the requested value OUT pSnr: the average value of the SNR RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: STA was not yet registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetSnr ( tANI_U8 ucSTAId, tANI_S8* pSnr ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if (NULL == pSnr) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on %s", __func__)); return VOS_STATUS_E_INVAL; } if (WLANTL_STA_ID_INVALID(ucSTAId)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on %s", __func__)); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(vos_get_global_context(VOS_MODULE_ID_TL, NULL)); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on %s", __func__)); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if (NULL == pClientSTA) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if (0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on %s", __func__)); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Copy will not be locked; please read restriction ------------------------------------------------------------------------*/ if (pTLCb->isBMPS) { *pSnr = pClientSTA->snrAvgBmps; } else { /* SNR is averaged over WLANTL_MAX_SNR_DATA_SAMPLES, if there are not enough * data samples (snridx) to calculate the average then return the * average for the window of prevoius 20 packets. And if there aren't * enough samples and the average for previous window of 20 packets is * not available then return a predefined value * * NOTE: the SNR_HACK_BMPS value is defined to 127, documents from HW * team reveal that the SNR value has a ceiling well below 127 dBm, * so if SNR has value of 127 the userspace applications can know that * the SNR has not been computed yet because enough data was not * available for SNR calculation */ if (pClientSTA->snrIdx > (WLANTL_MAX_SNR_DATA_SAMPLES/2) || !(pClientSTA->prevSnrAvg)) { *pSnr = pClientSTA->snrSum / pClientSTA->snrIdx; } else if (pClientSTA->prevSnrAvg) { *pSnr = pClientSTA->prevSnrAvg; } else { *pSnr = SNR_HACK_BMPS; } } VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_GetSnr for STA: %d SNR: %d%s", ucSTAId, *pSnr, pTLCb->isBMPS ? " in BMPS" : ""); return VOS_STATUS_SUCCESS; }/* WLANTL_GetSnr */ /*========================================================================== FUNCTION WLANTL_GetLinkQuality DESCRIPTION TL will extract the SNR information from every data packet from the ongoing traffic and will store it. It will provide the result to SME upon request. DEPENDENCIES WARNING: the read and write of this value will not be protected by locks, therefore the information obtained after a read might not always be consistent. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context ucSTAId: station identifier for the requested value OUT puLinkQuality: the average value of the SNR RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: STA was not yet registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetLinkQuality ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U32_t* puLinkQuality ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == puLinkQuality ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid parameter sent on WLANTL_GetLinkQuality")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid station id requested on WLANTL_GetLinkQuality")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid TL pointer from pvosGCtx on WLANTL_GetLinkQuality")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Station was not previously registered on WLANTL_GetLinkQuality")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Copy will not be locked; please read restriction ------------------------------------------------------------------------*/ *puLinkQuality = pClientSTA->uLinkQualityAvg; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLANTL_GetLinkQuality for STA: %d LinkQuality: %d", ucSTAId, *puLinkQuality)); return VOS_STATUS_SUCCESS; }/* WLANTL_GetLinkQuality */ /*========================================================================== FUNCTION WLANTL_FlushStaTID DESCRIPTION TL provides this API as an interface to SME (BAP) layer. TL inturn posts a message to HAL. This API is called by the SME inorder to perform a flush operation. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context ucSTAId: station identifier for the requested value ucTid: Tspec ID for the new BA session OUT The response for this post is received in the main thread, via a response message from HAL to TL. RETURN VALUE VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_FlushStaTID ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U8_t ucTid ) { WLANTL_CbType* pTLCb = NULL; tpFlushACReq FlushACReqPtr = NULL; vos_msg_t vosMessage; if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid station id requested on WLANTL_FlushStaTID")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid TL pointer from pvosGCtx on WLANTL_FlushStaTID")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Station was not previously registered on WLANTL_FlushStaTID")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ We need to post a message with the STA, TID value to HAL. HAL performs the flush ------------------------------------------------------------------------*/ FlushACReqPtr = vos_mem_malloc(sizeof(tFlushACReq)); if ( NULL == FlushACReqPtr ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: fatal failure, cannot allocate Flush Req structure")); VOS_ASSERT(0); return VOS_STATUS_E_NOMEM; } // Start constructing the message for HAL FlushACReqPtr->mesgType = SIR_TL_HAL_FLUSH_AC_REQ; FlushACReqPtr->mesgLen = sizeof(tFlushACReq); FlushACReqPtr->mesgLen = sizeof(tFlushACReq); FlushACReqPtr->ucSTAId = ucSTAId; FlushACReqPtr->ucTid = ucTid; vosMessage.type = WDA_TL_FLUSH_AC_REQ; vosMessage.bodyptr = (void *)FlushACReqPtr; vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage); return VOS_STATUS_SUCCESS; } /*---------------------------------------------------------------------------- INTERACTION WITH PE ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_updateSpoofMacAddr DESCRIPTION Called by HDD to update macaddr DEPENDENCIES TL must be initialized before this API can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context spoofMacAddr: spoofed mac adderess selfMacAddr: self Mac Address RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_updateSpoofMacAddr ( v_PVOID_t pvosGCtx, v_MACADDR_t* spoofMacAddr, v_MACADDR_t* selfMacAddr ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState"); return VOS_STATUS_E_FAULT; } vos_mem_copy(pTLCb->spoofMacAddr.selfMac.bytes, selfMacAddr, VOS_MAC_ADDRESS_LEN); vos_mem_copy(pTLCb->spoofMacAddr.spoofMac.bytes, spoofMacAddr, VOS_MAC_ADDRESS_LEN); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "TL: SelfSTA mac Addr for current Scan "MAC_ADDRESS_STR, MAC_ADDR_ARRAY(pTLCb->spoofMacAddr.selfMac.bytes)); return VOS_STATUS_SUCCESS; }/* WLANTL_updateSpoofMacAddr */ /*========================================================================== FUNCTION WLANTL_RegisterMgmtFrmClient DESCRIPTION Called by PE to register as a client for management frames delivery. DEPENDENCIES TL must be initialized before this API can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pfnTlMgmtFrmRx: pointer to the receive processing routine for management frames RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Mgmt Frame client was already registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RegisterMgmtFrmClient ( v_PVOID_t pvosGCtx, WLANTL_MgmtFrmRxCBType pfnTlMgmtFrmRx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pfnTlMgmtFrmRx ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RegisterMgmtFrmClient")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Make sure this is the first registration attempt ------------------------------------------------------------------------*/ if ( 0 != pTLCb->tlMgmtFrmClient.ucExists ) { pTLCb->tlMgmtFrmClient.ucExists++; TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Management frame client was already registered")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Register station with TL ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Registering Management Frame Client" )); pTLCb->tlMgmtFrmClient.ucExists++; if ( NULL != pfnTlMgmtFrmRx ) { pTLCb->tlMgmtFrmClient.pfnTlMgmtFrmRx = pfnTlMgmtFrmRx; } pTLCb->tlMgmtFrmClient.vosPendingDataBuff = NULL; return VOS_STATUS_SUCCESS; }/* WLANTL_RegisterMgmtFrmClient */ /*========================================================================== FUNCTION WLANTL_DeRegisterMgmtFrmClient DESCRIPTION Called by PE to deregister as a client for management frames delivery. DEPENDENCIES TL must be initialized before this API can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Mgmt Frame client was never registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_DeRegisterMgmtFrmClient ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Make sure this is the first registration attempt ------------------------------------------------------------------------*/ if ( 0 == pTLCb->tlMgmtFrmClient.ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Management frame client was never registered")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Clear registration with TL ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Deregistering Management Frame Client" )); pTLCb->tlMgmtFrmClient.pfnTlMgmtFrmRx = WLANTL_MgmtFrmRxDefaultCb; if ( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Management cache buffer not empty on deregistering" " - dropping packet" )); vos_pkt_return_packet(pTLCb->tlMgmtFrmClient.vosPendingDataBuff); pTLCb->tlMgmtFrmClient.vosPendingDataBuff = NULL; } pTLCb->tlMgmtFrmClient.ucExists = 0; return VOS_STATUS_SUCCESS; }/* WLANTL_RegisterMgmtFrmClient */ /*========================================================================== FUNCTION WLANTL_TxMgmtFrm DESCRIPTION Called by PE when it want to send out a management frame. HAL will also use this API for the few frames it sends out, they are not management frames howevere it is accepted that an exception will be allowed ONLY for the usage of HAL. Generic data frames SHOULD NOT travel through this function. DEPENDENCIES TL must be initialized before this API can be called. RESTRICTION: If PE sends another packet before TL manages to process the previously sent packet call will end in failure Frames comming through here must be 802.11 frames, frame translation in UMA will be automatically disabled. PARAMETERS IN pvosGCtx: pointer to the global vos context;a handle to TL's control block can be extracted from its context vosFrmBuf: pointer to a vOSS buffer containing the management frame to be transmitted usFrmLen: the length of the frame to be transmitted; information is already included in the vOSS buffer wFrmType: the type of the frame being transmitted tid: tid used to transmit this frame pfnCompTxFunc: function pointer to the transmit complete routine pvBDHeader: pointer to the BD header, if NULL it means it was not yet constructed and it lies within TL's responsibility to do so; if not NULL it is expected that it was already packed inside the vos packet ucAckResponse: flag notifying it an interrupt is needed for the acknowledgement received when the frame is sent out the air and ; the interrupt will be processed by HAL, only one such frame can be pending in the system at one time. RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Mgmt Frame client was not yet registered VOS_STATUS_E_BUSY: The previous Mgmt packet was not yet transmitted VOS_STATUS_SUCCESS: Everything is good :) Other failure messages may be returned from the BD header handling routines, please check apropriate API for more info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_TxMgmtFrm ( v_PVOID_t pvosGCtx, vos_pkt_t* vosFrmBuf, v_U16_t usFrmLen, v_U8_t wFrmType, v_U8_t ucTid, WLANTL_TxCompCBType pfnCompTxFunc, v_PVOID_t pvBDHeader, v_U32_t ucAckResponse, v_U32_t ucTxBdToken ) { WLANTL_CbType* pTLCb = NULL; v_MACADDR_t vDestMacAddr; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_U16_t usPktLen; v_U32_t usTimeStamp = 0; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == vosFrmBuf ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_TxMgmtFrm")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_TxMgmtFrm")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Ensure that management frame client was previously registered ------------------------------------------------------------------------*/ if ( 0 == pTLCb->tlMgmtFrmClient.ucExists ) { pTLCb->tlMgmtFrmClient.ucExists++; TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Management Frame client not register on WLANTL_TxMgmtFrm")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Check if any Mgmt Frm is pending ------------------------------------------------------------------------*/ //vosTempBuff = pTLCb->tlMgmtFrmClient.vosPendingDataBuff; if ( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Management Frame already pending tx in TL: failing old one")); /*Failing the tx for the previous packet enqued by PE*/ //vos_atomic_set( (uintptr_t*)&pTLCb->tlMgmtFrmClient.vosPendingDataBuff, // (uintptr_t)NULL); //vos_pkt_get_user_data_ptr( vosTempBuff, VOS_PKT_USER_DATA_ID_TL, // (v_PVOID_t)&pfnTxComp); /*it should never be NULL - default handler should be registered if none*/ //if ( NULL == pfnTxComp ) //{ // VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, // "NULL pointer to Tx Complete on WLANTL_TxMgmtFrm"); // VOS_ASSERT(0); // return VOS_STATUS_E_FAULT; //} //pfnTxComp( pvosGCtx, vosTempBuff, VOS_STATUS_E_RESOURCES ); //return VOS_STATUS_E_BUSY; //pfnCompTxFunc( pvosGCtx, vosFrmBuf, VOS_STATUS_E_RESOURCES); return VOS_STATUS_E_RESOURCES; } /*------------------------------------------------------------------------ Check if BD header was build, if not construct ------------------------------------------------------------------------*/ if ( NULL == pvBDHeader ) { v_MACADDR_t* pvAddr2MacAddr; v_U8_t uQosHdr = VOS_FALSE; /* Get address 2 of Mangement Frame to give to WLANHAL_FillTxBd */ vosStatus = vos_pkt_peek_data( vosFrmBuf, WLANTL_MAC_ADDR_ALIGN(1) + VOS_MAC_ADDR_SIZE, (v_PVOID_t)&pvAddr2MacAddr, VOS_MAC_ADDR_SIZE); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Failed while attempting to get addr2 %d", vosStatus)); return vosStatus; } /* ESE IAPP/TDLS Frame which are data frames but technically used * for management functionality comes through route. */ if (WLANTL_IS_QOS_DATA_FRAME(wFrmType)) \ { uQosHdr = VOS_TRUE; } if (WLANTL_IS_PROBE_REQ(wFrmType)) { if (VOS_TRUE == vos_mem_compare((v_VOID_t*) pvAddr2MacAddr, (v_VOID_t*) &pTLCb->spoofMacAddr.spoofMac, VOS_MAC_ADDRESS_LEN)) { pvAddr2MacAddr = (v_PVOID_t)pTLCb->spoofMacAddr.selfMac.bytes; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TL: using self sta addr to get staidx for spoofed probe req " MAC_ADDRESS_STR, MAC_ADDR_ARRAY(pvAddr2MacAddr->bytes)); } } /*---------------------------------------------------------------------- Call WDA to build TX header ----------------------------------------------------------------------*/ vosStatus = WDA_DS_BuildTxPacketInfo( pvosGCtx, vosFrmBuf , &vDestMacAddr, 1 /* always 802.11 frames*/, &usPktLen, uQosHdr /*qos not enabled !!!*/, 0 /* WDS off */, 0, wFrmType, pvAddr2MacAddr, ucTid, ucAckResponse, usTimeStamp, 0, 0, 0, ucTxBdToken); if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Failed while attempting to build TX header %d", vosStatus)); return vosStatus; } }/* if BD header not present */ /*------------------------------------------------------------------------ Save buffer and notify BAL; no lock is needed if the above restriction is met Save the tx complete fnct pointer as tl specific data in the vos buffer ------------------------------------------------------------------------*/ if ( NULL != pfnCompTxFunc ) { vos_pkt_set_user_data_ptr( vosFrmBuf, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)pfnCompTxFunc); } else { vos_pkt_set_user_data_ptr( vosFrmBuf, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)WLANTL_TxCompDefaultCb); } vos_atomic_set( (uintptr_t*)&pTLCb->tlMgmtFrmClient.vosPendingDataBuff, (uintptr_t)vosFrmBuf); /*------------------------------------------------------------------------ Check if thre are enough resources for transmission and tx is not suspended. ------------------------------------------------------------------------*/ if ( pTLCb->uResCount >= WDA_TLI_MIN_RES_MF ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Issuing Xmit start request to BAL for MGMT")); vosStatus = WDA_DS_StartXmit(pvosGCtx); if(VOS_STATUS_SUCCESS != vosStatus) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:WDA_DS_StartXmit fails. vosStatus %d", vosStatus)); vos_atomic_set( (uintptr_t*)&pTLCb->tlMgmtFrmClient.vosPendingDataBuff,0); } return vosStatus; } else { /*--------------------------------------------------------------------- No error code is sent because TL will resume tx autonomously if resources become available or tx gets resumed ---------------------------------------------------------------------*/ TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Request to send for Mgmt Frm but condition not met. Res: %d", pTLCb->uResCount)); } return VOS_STATUS_SUCCESS; }/* WLANTL_TxMgmtFrm */ /*---------------------------------------------------------------------------- INTERACTION WITH HAL ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_ResetNotification DESCRIPTION HAL notifies TL when the module is being reset. Currently not used. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ResetNotification ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ResetNotification")); return VOS_STATUS_E_FAULT; } WLANTL_CleanCB(pTLCb, 1 /*empty all queues and pending packets*/); return VOS_STATUS_SUCCESS; }/* WLANTL_ResetNotification */ /*========================================================================== FUNCTION WLANTL_SuspendDataTx DESCRIPTION HAL calls this API when it wishes to suspend transmission for a particular STA. DEPENDENCIES The STA for which the request is made must be first registered with TL by HDD. RESTRICTION: In case of a suspend, the flag write and read will not be locked: worst case scenario one more packet can get through before the flag gets updated (we can make this write atomic as well to guarantee consistency) PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pucSTAId: identifier of the station for which the request is made; a value of NULL assumes suspend on all active station pfnSuspendTxCB: pointer to the suspend result notification in case the call is asynchronous RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_SuspendDataTx ( v_PVOID_t pvosGCtx, v_U8_t* pucSTAId, WLANTL_SuspendCBType pfnSuspendTx ) { WLANTL_CbType* pTLCb = NULL; vos_msg_t vosMsg; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_SuspendDataTx")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Check the type of request: generic suspend, or per station suspend ------------------------------------------------------------------------*/ if (NULL == pucSTAId) { /* General Suspend Request received */ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:General suspend requested")); vos_atomic_set_U8( &pTLCb->ucTxSuspended, 1); vosMsg.reserved = WLAN_MAX_STA_COUNT; } else { if ( WLANTL_STA_ID_INVALID( *pucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id %d requested on WLANTL_SuspendDataTx", *pucSTAId)); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[*pucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid pTLCb->atlSTAClients pointer for STA Id :%d on " "WLANTL_SuspendDataTx", *pucSTAId)); return VOS_STATUS_E_FAULT; } if ( 0 == pTLCb->atlSTAClients[*pucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station %d was not previously registered on WLANTL_SuspendDataTx", *pucSTAId)); return VOS_STATUS_E_EXISTS; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Suspend request for station: %d", *pucSTAId)); vos_atomic_set_U8( &pTLCb->atlSTAClients[*pucSTAId]->ucTxSuspended, 1); vosMsg.reserved = *pucSTAId; } /*------------------------------------------------------------------------ Serialize request through TX thread ------------------------------------------------------------------------*/ vosMsg.type = WLANTL_TX_SIG_SUSPEND; vosMsg.bodyptr = (v_PVOID_t)pfnSuspendTx; MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_SUSPEND_DATA_TX, vosMsg.reserved , 0 )); if(!VOS_IS_STATUS_SUCCESS(vos_tx_mq_serialize( VOS_MQ_ID_TL, &vosMsg))) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s fails to post message", __func__); } return VOS_STATUS_SUCCESS; }/* WLANTL_SuspendDataTx */ /*========================================================================== FUNCTION WLANTL_ResumeDataTx DESCRIPTION Called by HAL to resume data transmission for a given STA. WARNING: If a station was individually suspended a global resume will not resume that station DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pucSTAId: identifier of the station which is being resumed; NULL translates into global resume RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ResumeDataTx ( v_PVOID_t pvosGCtx, v_U8_t* pucSTAId ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ResumeDataTx")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Check to see the type of resume ------------------------------------------------------------------------*/ if ( NULL == pucSTAId ) { MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_RESUME_DATA_TX, 41 , 0 )); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:General resume requested")); vos_atomic_set_U8( &pTLCb->ucTxSuspended, 0); } else { MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_RESUME_DATA_TX, *pucSTAId , 0 )); if ( WLANTL_STA_ID_INVALID( *pucSTAId )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id %d requested on WLANTL_ResumeDataTx", *pucSTAId)); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[*pucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid pTLCb->atlSTAClients pointer for STA Id :%d on " "WLANTL_ResumeDataTx", *pucSTAId)); return VOS_STATUS_E_FAULT; } if ( 0 == pTLCb->atlSTAClients[*pucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station %d was not previously registered on WLANTL_ResumeDataTx", *pucSTAId)); return VOS_STATUS_E_EXISTS; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Resume request for station: %d", *pucSTAId)); vos_atomic_set_U8( &pTLCb->atlSTAClients[*pucSTAId]->ucTxSuspended, 0); } /*------------------------------------------------------------------------ Resuming transmission ------------------------------------------------------------------------*/ if (( pTLCb->uResCount >= WDA_TLI_MIN_RES_MF ) && ( 0 == pTLCb->ucTxSuspended )) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Resuming transmission")); return WDA_DS_StartXmit(pvosGCtx); } return VOS_STATUS_SUCCESS; }/* WLANTL_ResumeDataTx */ /*========================================================================== FUNCTION WLANTL_SuspendCB DESCRIPTION Callback function for serializing Suspend signal through Tx thread DEPENDENCIES Just notify HAL that suspend in TL is complete. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context pUserData: user data sent with the callback RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_SuspendCB ( v_PVOID_t pvosGCtx, WLANTL_SuspendCBType pfnSuspendCB, v_U16_t usReserved ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucSTAId = (v_U8_t)usReserved; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pfnSuspendCB ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: No Call back processing requested WLANTL_SuspendCB")); return VOS_STATUS_SUCCESS; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_SuspendCB")); return VOS_STATUS_E_FAULT; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { pfnSuspendCB(pvosGCtx, NULL, VOS_STATUS_SUCCESS); } else { pfnSuspendCB(pvosGCtx, &ucSTAId, VOS_STATUS_SUCCESS); } return VOS_STATUS_SUCCESS; }/*WLANTL_SuspendCB*/ /*---------------------------------------------------------------------------- CLIENT INDEPENDENT INTERFACE ---------------------------------------------------------------------------*/ /*========================================================================== FUNCTION WLANTL_GetTxPktCount DESCRIPTION TL will provide the number of transmitted packets counted per STA per TID. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station ucTid: identifier of the tspec OUT puTxPktCount: the number of packets tx packet for this STA and TID RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetTxPktCount ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U8_t ucTid, v_U32_t* puTxPktCount ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == puTxPktCount ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetTxPktCount")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) || WLANTL_TID_INVALID( ucTid) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id %d/tid %d requested on WLANTL_GetTxPktCount", ucSTAId, ucTid)); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check if station exists ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetTxPktCount")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_GetTxPktCount %d", ucSTAId)); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Return data ------------------------------------------------------------------------*/ //VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_MED, // "WLAN TL:Requested tx packet count for STA: %d, TID: %d", // ucSTAId, ucTid); *puTxPktCount = pTLCb->atlSTAClients[ucSTAId]->auTxCount[ucTid]; return VOS_STATUS_SUCCESS; }/* WLANTL_GetTxPktCount */ /*========================================================================== FUNCTION WLANTL_GetRxPktCount DESCRIPTION TL will provide the number of received packets counted per STA per TID. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station ucTid: identifier of the tspec OUT puTxPktCount: the number of packets rx packet for this STA and TID RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetRxPktCount ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U8_t ucTid, v_U32_t* puRxPktCount ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == puRxPktCount ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetRxPktCount")); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) || WLANTL_TID_INVALID( ucTid) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id %d/tid %d requested on WLANTL_GetRxPktCount", ucSTAId, ucTid)); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetRxPktCount")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Station was not previously registered on WLANTL_GetRxPktCount")); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Return data ------------------------------------------------------------------------*/ TLLOG3(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_MED, "WLAN TL:Requested rx packet count for STA: %d, TID: %d", ucSTAId, ucTid)); *puRxPktCount = pClientSTA->auRxCount[ucTid]; return VOS_STATUS_SUCCESS; }/* WLANTL_GetRxPktCount */ VOS_STATUS WLANTL_TxFCFrame ( v_PVOID_t pvosGCtx ); /*========================================================================== FUNCTION WLANTL_IsEAPOLPending DESCRIPTION HDD calls this function when hdd_tx_timeout occurs. This checks whether EAPOL is pending. DEPENDENCIES HDD must have registered with TL at least one STA before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context RETURN VALUE The result code associated with performing the operation Success : Indicates EAPOL frame is pending and sta is in connected state Failure : EAPOL frame is not pending SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_IsEAPOLPending ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; v_U32_t i = 0; /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer for pvosGCtx")); return VOS_STATUS_E_FAILURE; } /*--------------------------------------------------------------------- Check to see if there was any EAPOL packet is pending *--------------------------------------------------------------------*/ for ( i = 0; i < WLAN_MAX_STA_COUNT; i++) { if ((NULL != pTLCb->atlSTAClients[i]) && (pTLCb->atlSTAClients[i]->ucExists) && (0 == pTLCb->atlSTAClients[i]->ucTxSuspended) && (WLANTL_STA_CONNECTED == pTLCb->atlSTAClients[i]->tlState) && (pTLCb->atlSTAClients[i]->ucPktPending) ) return VOS_STATUS_SUCCESS; } return VOS_STATUS_E_FAILURE; } /*============================================================================ TL INTERNAL API DEFINITION ============================================================================*/ /*========================================================================== FUNCTION WLANTL_GetFrames DESCRIPTION BAL calls this function at the request of the lower bus interface. When this request is being received TL will retrieve packets from HDD in accordance with the priority rules and the count supplied by BAL. DEPENDENCIES HDD must have registered with TL at least one STA before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or BAL's control block can be extracted from its context uSize: maximum size accepted by the lower layer uFlowMask TX flow control mask for Prima. Each bit is defined as WDA_TXFlowEnumType OUT vosDataBuff: it will contain a pointer to the first buffer supplied by TL, if there is more than one packet supplied, TL will chain them through vOSS buffers RETURN VALUE The result code associated with performing the operation 1 or more: number of required resources if there are still frames to fetch 0 : error or HDD queues are drained SIDE EFFECTS NOTE Featurized uFlowMask. If we want to remove featurization, we need to change BAL on Volans. ============================================================================*/ v_U32_t WLANTL_GetFrames ( v_PVOID_t pvosGCtx, vos_pkt_t **ppFrameDataBuff, v_U32_t uSize, v_U8_t uFlowMask, v_BOOL_t* pbUrgent ) { vos_pkt_t** pvosDataBuff = (vos_pkt_t**)ppFrameDataBuff; WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; v_U32_t uRemaining = uSize; vos_pkt_t* vosRoot; vos_pkt_t* vosTempBuf; WLANTL_STAFuncType pfnSTAFsm; v_U16_t usPktLen; v_U32_t uResLen; v_U8_t ucSTAId; v_U8_t ucAC; vos_pkt_t* vosDataBuff; v_U32_t uTotalPktLen; v_U32_t i=0; v_U32_t j=0; v_U32_t ucResult = 0; VOS_STATUS vosStatus; WLANTL_STAEventType wSTAEvent; tBssSystemRole systemRole; tpAniSirGlobal pMac; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (( NULL == pTLCb ) || ( NULL == pvosDataBuff )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return ucResult; } pMac = vos_get_context(VOS_MODULE_ID_PE, pvosGCtx); if ( NULL == pMac ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid pMac", __func__)); return ucResult; } vosDataBuff = pTLCb->vosDummyBuf; /* Just to avoid checking for NULL at each iteration */ pTLCb->uResCount = uSize; /*----------------------------------------------------------------------- Save the root as we will walk this chain as we fill it -----------------------------------------------------------------------*/ vosRoot = vosDataBuff; /*----------------------------------------------------------------------- There is still data - until FSM function says otherwise -----------------------------------------------------------------------*/ pTLCb->bUrgent = FALSE; while (( pTLCb->tlConfigInfo.uMinFramesProcThres < pTLCb->uResCount ) && ( 0 < uRemaining )) { systemRole = wdaGetGlobalSystemRole(pMac); #ifdef WLAN_SOFTAP_FLOWCTRL_EN /* FIXME: The code has been disabled since it is creating issues in power save */ if (eSYSTEM_AP_ROLE == systemRole) { if (pTLCb->done_once == 0 && NULL == pTLCb->vosTxFCBuf) { WLANTL_TxFCFrame (pvosGCtx); pTLCb->done_once ++; } } if ( NULL != pTLCb->vosTxFCBuf ) { //there is flow control packet waiting to be sent WDA_TLI_PROCESS_FRAME_LEN( pTLCb->vosTxFCBuf, usPktLen, uResLen, uTotalPktLen); if ( ( pTLCb->uResCount > uResLen ) && ( uRemaining > uTotalPktLen ) && ( uFlowMask & ( 1 << WDA_TXFLOW_FC ) ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining FC frame first on GetFrame")); vos_pkt_chain_packet( vosDataBuff, pTLCb->vosTxFCBuf, 1 /*true*/ ); vos_atomic_set( (uintptr_t*)&pTLCb->vosTxFCBuf, (uintptr_t) NULL); /*FC frames cannot be delayed*/ pTLCb->bUrgent = TRUE; /*Update remaining len from SSC */ uRemaining -= (usPktLen + WDA_DXE_HEADER_SIZE); /*Update resource count */ pTLCb->uResCount -= uResLen; } else { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:send fc out of source %s", __func__)); ucResult = ( pTLCb->uResCount > uResLen )?VOS_TRUE:VOS_FALSE; break; /* Out of resources or reached max len */ } } else #endif //WLAN_SOFTAP_FLOWCTRL_EN if (( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff ) && ( uFlowMask & ( 1 << WDA_TXFLOW_MGMT ) ) ) { WDA_TLI_PROCESS_FRAME_LEN( pTLCb->tlMgmtFrmClient.vosPendingDataBuff, usPktLen, uResLen, uTotalPktLen); if (usPktLen > WLANTL_MAX_ALLOWED_LEN) { usPktLen = WLANTL_MAX_ALLOWED_LEN; VOS_ASSERT(0); } if ( ( pTLCb->uResCount > uResLen ) && ( uRemaining > uTotalPktLen ) && ( uFlowMask & ( 1 << WDA_TXFLOW_MGMT ) ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining management frame on GetFrame")); vos_pkt_chain_packet( vosDataBuff, pTLCb->tlMgmtFrmClient.vosPendingDataBuff, 1 /*true*/ ); vos_atomic_set( (uintptr_t*)&pTLCb->tlMgmtFrmClient. vosPendingDataBuff, (uintptr_t)NULL); /*management frames cannot be delayed*/ pTLCb->bUrgent = TRUE; /*Update remaining len from SSC */ uRemaining -= (usPktLen + WDA_DXE_HEADER_SIZE); /*Update resource count */ pTLCb->uResCount -= uResLen; } else { ucResult = ( pTLCb->uResCount > uResLen )?VOS_TRUE:VOS_FALSE; break; /* Out of resources or reached max len */ } } else if (( pTLCb->tlBAPClient.vosPendingDataBuff ) && ( WDA_TLI_MIN_RES_BAP <= pTLCb->uResCount ) && ( 0 == pTLCb->ucTxSuspended ) ) { WDA_TLI_PROCESS_FRAME_LEN( pTLCb->tlBAPClient.vosPendingDataBuff, usPktLen, uResLen, uTotalPktLen); if (usPktLen > WLANTL_MAX_ALLOWED_LEN) { usPktLen = WLANTL_MAX_ALLOWED_LEN; VOS_ASSERT(0); } if ( ( pTLCb->uResCount > (uResLen + WDA_TLI_MIN_RES_MF ) ) && ( uRemaining > uTotalPktLen )) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining BT-AMP frame on GetFrame")); vos_pkt_chain_packet( vosDataBuff, pTLCb->tlBAPClient.vosPendingDataBuff, 1 /*true*/ ); /*BAP frames cannot be delayed*/ pTLCb->bUrgent = TRUE; vos_atomic_set( (uintptr_t*)&pTLCb->tlBAPClient.vosPendingDataBuff, (uintptr_t) NULL); /*Update remaining len from SSC */ uRemaining -= (usPktLen + WDA_DXE_HEADER_SIZE); /*Update resource count */ pTLCb->uResCount -= uResLen; } else { ucResult = uResLen + WDA_TLI_MIN_RES_MF; break; /* Out of resources or reached max len */ } } /* note: this feature implemented only after WLAN_INGETRATED_SOC */ /* search 'EAPOL_HI_PRIORITY' will show EAPOL HI_PRIORITY change in TL and WDI by default, EAPOL will be treated as higher priority, which means use mgmt_pool and DXE_TX_HI prority channel. this is introduced to address EAPOL failure under high background traffic with multi-channel concurrent mode. But this change works in SCC or standalone, too. see CR#387009 and WCNSOS-8 */ else if (( WDA_TLI_MIN_RES_MF <= pTLCb->uResCount )&& ( 0 == pTLCb->ucTxSuspended ) && ( uFlowMask & ( 1 << WDA_TXFLOW_MGMT ) ) ) { vosTempBuf = NULL; /*--------------------------------------------------------------------- Check to see if there was any EAPOL packet is pending *--------------------------------------------------------------------*/ for ( i = 0; i < WLAN_MAX_STA_COUNT; i++) { if ((NULL != pTLCb->atlSTAClients[i]) && (pTLCb->atlSTAClients[i]->ucExists) && (0 == pTLCb->atlSTAClients[i]->ucTxSuspended) && (WLANTL_STA_CONNECTED == pTLCb->atlSTAClients[i]->tlState) && (pTLCb->atlSTAClients[i]->ucPktPending) ) break; } if (i >= WLAN_MAX_STA_COUNT) { /* No More to Serve Exit Get Frames */ break; } /* Serve EAPOL frame with HI_FLOW_MASK */ ucSTAId = i; pClientSTA = pTLCb->atlSTAClients[ucSTAId]; MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_GET_FRAMES_EAPOL, ucSTAId, pClientSTA->tlState)); if (pClientSTA->wSTADesc.wSTAType == WLAN_STA_INFRA) { if(0 != pClientSTA->aucACMask[WLANTL_AC_HIGH_PRIO]) { pClientSTA->ucCurrentAC = WLANTL_AC_HIGH_PRIO; pTLCb->uCurServedAC = WLANTL_AC_HIGH_PRIO; } else break; } else { for (j = WLANTL_MAX_AC ; j > 0; j--) { if (0 != pClientSTA->aucACMask[j-1]) { pClientSTA->ucCurrentAC = j-1; pTLCb->uCurServedAC = j-1; break; } } } wSTAEvent = WLANTL_TX_EVENT; pfnSTAFsm = tlSTAFsm[pClientSTA->tlState]. pfnSTATbl[wSTAEvent]; if ( NULL != pfnSTAFsm ) { pClientSTA->ucNoMoreData = 0; vosStatus = pfnSTAFsm( pvosGCtx, ucSTAId, &vosTempBuf, VOS_FALSE); if (( VOS_STATUS_SUCCESS != vosStatus ) && ( NULL != vosTempBuf )) { pClientSTA->pfnSTATxComp( pvosGCtx, vosTempBuf, vosStatus ); vosTempBuf = NULL; break; }/* status success*/ } if (NULL != vosTempBuf) { WDA_TLI_PROCESS_FRAME_LEN( vosTempBuf, usPktLen, uResLen, uTotalPktLen); if (usPktLen > WLANTL_MAX_ALLOWED_LEN) { usPktLen = WLANTL_MAX_ALLOWED_LEN; VOS_ASSERT(0); } TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL:Resources needed by frame: %d", uResLen)); if ( ( pTLCb->uResCount >= (uResLen + WDA_TLI_MIN_RES_MF ) ) && ( uRemaining > uTotalPktLen ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining data frame on GetFrame")); vos_pkt_chain_packet( vosDataBuff, vosTempBuf, 1 /*true*/ ); /*EAPOL frame cannot be delayed*/ pTLCb->bUrgent = TRUE; vosTempBuf = NULL; /*Update remaining len from SSC */ uRemaining -= (usPktLen + WDA_DXE_HEADER_SIZE); /*Update resource count */ pTLCb->uResCount -= uResLen; //fow control update pClientSTA->uIngress_length += uResLen; pClientSTA->uBuffThresholdMax = (pClientSTA->uBuffThresholdMax >= uResLen) ? (pClientSTA->uBuffThresholdMax - uResLen) : 0; pClientSTA->ucEapolPktPending = 0; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:GetFrames STA: %d EAPOLPktPending %d", ucSTAId, pClientSTA->ucEapolPktPending); } } else { // no EAPOL frames exit Get frames TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:GetFrames STA: %d, no EAPOL frame, continue.", ucSTAId)); continue; } } else if (( WDA_TLI_MIN_RES_DATA <= pTLCb->uResCount ) && ( 0 == pTLCb->ucTxSuspended ) && ( uFlowMask & WLANTL_DATA_FLOW_MASK)) { /*--------------------------------------------------------------------- Check to see if there was any packet left behind previously due to size constraints ---------------------------------------------------------------------*/ vosTempBuf = NULL; if ( NULL != pTLCb->vosTempBuf ) { vosTempBuf = pTLCb->vosTempBuf; pTLCb->vosTempBuf = NULL; ucSTAId = pTLCb->ucCachedSTAId; ucAC = pTLCb->ucCachedAC; if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); continue; } pTLCb->atlSTAClients[ucSTAId]->ucNoMoreData = 0; pClientSTA = pTLCb->atlSTAClients[ucSTAId]; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining cached data frame on GetFrame")); } else { WLAN_TLGetNextTxIds( pvosGCtx, &ucSTAId); if (ucSTAId >= WLAN_MAX_STA_COUNT) { /* Packets start coming in even after insmod Without * starting Hostapd or Interface being up * During which cases STAID is invaled and hence the check. HalMsg_ScnaComplete Triggers */ break; } /* ucCurrentAC should have correct AC to be served by calling WLAN_TLGetNextTxIds */ pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); continue; } ucAC = pClientSTA->ucCurrentAC; pClientSTA->ucNoMoreData = 1; TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL: %s get one data frame, station ID %d ", __func__, ucSTAId)); /*------------------------------------------------------------------- Check to see that STA is valid and tx is not suspended -------------------------------------------------------------------*/ if ( ( ! WLANTL_STA_ID_INVALID( ucSTAId ) ) && ( 0 == pClientSTA->ucTxSuspended ) && ( 0 == pClientSTA->fcStaTxDisabled) ) { TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL: %s sta id valid and not suspended ",__func__)); wSTAEvent = WLANTL_TX_EVENT; pfnSTAFsm = tlSTAFsm[pClientSTA->tlState]. pfnSTATbl[wSTAEvent]; if ( NULL != pfnSTAFsm ) { pClientSTA->ucNoMoreData = 0; vosStatus = pfnSTAFsm( pvosGCtx, ucSTAId, &vosTempBuf, VOS_FALSE); if (( VOS_STATUS_SUCCESS != vosStatus ) && ( NULL != vosTempBuf )) { pClientSTA->pfnSTATxComp( pvosGCtx, vosTempBuf, vosStatus ); vosTempBuf = NULL; }/* status success*/ }/*NULL function state*/ }/* valid STA id and ! suspended*/ else { if ( ! WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_DEBUG, "WLAN TL:Not fetching frame because suspended for sta ID %d", ucSTAId)); } } }/* data */ if ( NULL != vosTempBuf ) { WDA_TLI_PROCESS_FRAME_LEN( vosTempBuf, usPktLen, uResLen, uTotalPktLen); if (usPktLen > WLANTL_MAX_ALLOWED_LEN) { usPktLen = WLANTL_MAX_ALLOWED_LEN; VOS_ASSERT(0); } TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL:Resources needed by frame: %d", uResLen)); if ( ( pTLCb->uResCount >= (uResLen + WDA_TLI_MIN_RES_BAP ) ) && ( uRemaining > uTotalPktLen ) && ( uFlowMask & WLANTL_DATA_FLOW_MASK ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Chaining data frame on GetFrame")); vos_pkt_chain_packet( vosDataBuff, vosTempBuf, 1 /*true*/ ); vosTempBuf = NULL; /*Update remaining len from SSC */ uRemaining -= (usPktLen + WDA_DXE_HEADER_SIZE); /*Update resource count */ pTLCb->uResCount -= uResLen; //fow control update pClientSTA->uIngress_length += uResLen; pClientSTA->uBuffThresholdMax = (pClientSTA->uBuffThresholdMax >= uResLen) ? (pClientSTA->uBuffThresholdMax - uResLen) : 0; pClientSTA->tx_frames ++; } else { /* Store this for later tx - already fetched from HDD */ pTLCb->vosTempBuf = vosTempBuf; pTLCb->ucCachedSTAId = ucSTAId; pTLCb->ucCachedAC = ucAC; ucResult = uResLen + WDA_TLI_MIN_RES_BAP; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "min %d res required by TL.", ucResult )); break; /* Out of resources or reached max len */ } } else { for ( i = 0; i < WLAN_MAX_STA_COUNT; i++) { if (NULL != pTLCb->atlSTAClients[i] && (pTLCb->atlSTAClients[i]->ucExists) && (pTLCb->atlSTAClients[i]->ucPktPending) && (pTLCb->atlSTAClients[i]->disassoc_progress == VOS_FALSE)) { /* There is station to be Served */ break; } } if (i >= WLAN_MAX_STA_COUNT) { /* No More to Serve Exit Get Frames */ break; } else { /* More to be Served */ continue; } } } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Returning from GetFrame: resources = %d suspended = %d", pTLCb->uResCount, pTLCb->ucTxSuspended)); /* TL is starving even when DXE is not in low resource condition Return min resource number required and Let DXE deceide what to do */ if(( 0 == pTLCb->ucTxSuspended ) && ( uFlowMask & WLANTL_DATA_FLOW_MASK ) ) { TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:Returning from GetFrame: resources = %d", pTLCb->uResCount)); ucResult = WDA_TLI_MIN_RES_DATA; } break; /*out of min data resources*/ } pTLCb->usPendingTxCompleteCount++; /* Move data buffer up one packet */ vos_pkt_walk_packet_chain( vosDataBuff, &vosDataBuff, 0/*false*/ ); } /*---------------------------------------------------------------------- Packet chain starts at root + 1 ----------------------------------------------------------------------*/ vos_pkt_walk_packet_chain( vosRoot, &vosDataBuff, 1/*true*/ ); *pvosDataBuff = vosDataBuff; if (pbUrgent) { *pbUrgent = pTLCb->bUrgent; } else { VOS_ASSERT( pbUrgent ); } return ucResult; }/* WLANTL_GetFrames */ /*========================================================================== FUNCTION WLANTL_TxComp DESCRIPTION It is being called by BAL upon asynchronous notification of the packet or packets being sent over the bus. DEPENDENCIES Tx complete cannot be called without a previous transmit. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or BAL's control block can be extracted from its context vosDataBuff: it will contain a pointer to the first buffer for which the BAL report is being made, if there is more then one packet they will be chained using vOSS buffers. wTxStatus: the status of the transmitted packet, see above chapter on HDD interaction for a list of possible values RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_TxComp ( v_PVOID_t pvosGCtx, vos_pkt_t *pFrameDataBuff, VOS_STATUS wTxStatus ) { vos_pkt_t* vosDataBuff = (vos_pkt_t*)pFrameDataBuff; WLANTL_CbType* pTLCb = NULL; WLANTL_TxCompCBType pfnTxComp = NULL; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; vos_pkt_t* vosTempTx = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == vosDataBuff ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Extraneous NULL data pointer on WLANTL_TxComp")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_TxComp")); return VOS_STATUS_E_FAULT; } while ((0 < pTLCb->usPendingTxCompleteCount) && ( VOS_STATUS_SUCCESS == vosStatus ) && ( NULL != vosDataBuff)) { vos_pkt_get_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)&pfnTxComp); /*it should never be NULL - default handler should be registered if none*/ if ( NULL == pfnTxComp ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:NULL pointer to Tx Complete on WLANTL_TxComp")); VOS_ASSERT(0); return VOS_STATUS_E_FAULT; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Calling Tx complete for pkt %pK in function %pK", vosDataBuff, pfnTxComp)); vosTempTx = vosDataBuff; vosStatus = vos_pkt_walk_packet_chain( vosDataBuff, &vosDataBuff, 1/*true*/); pfnTxComp( pvosGCtx, vosTempTx, wTxStatus ); pTLCb->usPendingTxCompleteCount--; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: current TL values are: resources = %d " "pTLCb->usPendingTxCompleteCount = %d", pTLCb->uResCount, pTLCb->usPendingTxCompleteCount)); return VOS_STATUS_SUCCESS; }/* WLANTL_TxComp */ /*========================================================================== FUNCTION WLANTL_CacheSTAFrame DESCRIPTION Internal utility function for for caching incoming data frames that do not have a registered station yet. DEPENDENCIES TL must be initiailized before this function gets called. In order to benefit from thsi caching, the components must ensure that they will only register with TL at the moment when they are fully setup and ready to receive incoming data PARAMETERS IN pTLCb: TL control block ucSTAId: station id vosTempBuff: the data packet uDPUSig: DPU signature of the incoming packet bBcast: true if packet had the MC/BC bit set RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL or STA Id invalid ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ static VOS_STATUS WLANTL_CacheSTAFrame ( WLANTL_CbType* pTLCb, v_U8_t ucSTAId, vos_pkt_t* vosTempBuff, v_U32_t uDPUSig, v_U8_t bBcast, v_U8_t ucFrmType ) { v_U8_t ucUcastSig; v_U8_t ucBcastSig; v_BOOL_t bOldSTAPkt; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /*------------------------------------------------------------------------- Sanity check -------------------------------------------------------------------------*/ if (( NULL == pTLCb ) || ( NULL == vosTempBuff ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Invalid input pointer on WLANTL_CacheSTAFrame TL %pK" " Packet %pK", pTLCb, vosTempBuff )); return VOS_STATUS_E_FAULT; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_CacheSTAFrame")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Attempting to cache pkt for STA %d, BD DPU Sig: %d with sig UC: %d, BC: %d", ucSTAId, uDPUSig, pClientSTA->wSTADesc.ucUcastSig, pClientSTA->wSTADesc.ucBcastSig)); if(WLANTL_IS_CTRL_FRAME(ucFrmType)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: No need to cache CTRL frame. Dropping")); vos_pkt_return_packet(vosTempBuff); return VOS_STATUS_SUCCESS; } /*------------------------------------------------------------------------- Check if the packet that we are trying to cache belongs to the old registered station (if any) or the new (potentially)upcoming station - If the STA with this Id was never registered with TL - the signature will be invalid; - If the STA was previously registered TL will have cached the former set of DPU signatures -------------------------------------------------------------------------*/ if ( bBcast ) { ucBcastSig = (v_U8_t)uDPUSig; bOldSTAPkt = (( WLAN_TL_INVALID_B_SIG != pClientSTA->wSTADesc.ucBcastSig ) && ( ucBcastSig == pClientSTA->wSTADesc.ucBcastSig )); } else { ucUcastSig = (v_U8_t)uDPUSig; bOldSTAPkt = (( WLAN_TL_INVALID_U_SIG != pClientSTA->wSTADesc.ucUcastSig ) && ( ucUcastSig == pClientSTA->wSTADesc.ucUcastSig )); } /*------------------------------------------------------------------------ If the value of the DPU SIG matches the old, this packet will not be cached as it belonged to the former association In case the SIG does not match - this is a packet for a potentially new associated station -------------------------------------------------------------------------*/ if ( bOldSTAPkt || bBcast ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Data packet matches old sig for sig DPU: %d UC: %d, " "BC: %d - dropping", uDPUSig, pClientSTA->wSTADesc.ucUcastSig, pClientSTA->wSTADesc.ucBcastSig)); vos_pkt_return_packet(vosTempBuff); } else { if ( NULL == pClientSTA->vosBegCachedFrame ) { /*this is the first frame that we are caching */ pClientSTA->vosBegCachedFrame = vosTempBuff; pClientSTA->tlCacheInfo.cacheInitTime = vos_timer_get_system_time(); pClientSTA->tlCacheInfo.cacheDoneTime = pClientSTA->tlCacheInfo.cacheInitTime; pClientSTA->tlCacheInfo.cacheSize = 1; MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_CACHE_FRAME, ucSTAId, pClientSTA->tlCacheInfo.cacheSize)); } else { /*this is a subsequent frame that we are caching: chain to the end */ vos_pkt_chain_packet(pClientSTA->vosEndCachedFrame, vosTempBuff, VOS_TRUE); pClientSTA->tlCacheInfo.cacheDoneTime = vos_timer_get_system_time(); pClientSTA->tlCacheInfo.cacheSize ++; if (pClientSTA->tlCacheInfo.cacheSize % WLANTL_CACHE_TRACE_WATERMARK == 0) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Cache High watermark for staid:%d (%d)", __func__,ucSTAId, pClientSTA->tlCacheInfo.cacheSize); MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_CACHE_FRAME, ucSTAId, pClientSTA->tlCacheInfo.cacheSize)); } } pClientSTA->vosEndCachedFrame = vosTempBuff; }/*else new packet*/ return VOS_STATUS_SUCCESS; }/*WLANTL_CacheSTAFrame*/ /*========================================================================== FUNCTION WLANTL_FlushCachedFrames DESCRIPTION Internal utility function used by TL to flush the station cache DEPENDENCIES TL must be initiailized before this function gets called. PARAMETERS IN vosDataBuff: it will contain a pointer to the first cached buffer received, RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS NOTE This function doesn't re-initialize vosDataBuff to NULL. It's caller's responsibility to do so, if required, after this function call. Because of this restriction, we decide to make this function to static so that upper layer doesn't need to be aware of this restriction. ============================================================================*/ static VOS_STATUS WLANTL_FlushCachedFrames ( vos_pkt_t* vosDataBuff ) { /*---------------------------------------------------------------------- Return the entire chain to vos if there are indeed cache frames ----------------------------------------------------------------------*/ if ( NULL != vosDataBuff ) { vos_pkt_return_packet(vosDataBuff); } return VOS_STATUS_SUCCESS; }/*WLANTL_FlushCachedFrames*/ /*========================================================================== FUNCTION WLANTL_ForwardSTAFrames DESCRIPTION Internal utility function for either forwarding cached data to the station after the station has been registered, or flushing cached data if the station has not been registered. DEPENDENCIES TL must be initiailized before this function gets called. PARAMETERS IN pTLCb: TL control block ucSTAId: station id RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS This function doesn't re-initialize vosDataBuff to NULL. It's caller's responsibility to do so, if required, after this function call. Because of this restriction, we decide to make this function to static so that upper layer doesn't need to be aware of this restriction. ============================================================================*/ static VOS_STATUS WLANTL_ForwardSTAFrames ( void* pvosGCtx, v_U8_t ucSTAId, v_U8_t ucUcastSig, v_U8_t ucBcastSig ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /*------------------------------------------------------------------------- Sanity check -------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Invalid input pointer on WLANTL_ForwardSTAFrames TL %pK", pTLCb )); return VOS_STATUS_E_FAULT; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_ForwardSTAFrames")); return VOS_STATUS_E_FAULT; } //WLAN_TL_LOCK_STA_CACHE(pTLCb->atlSTAClients[ucSTAId]); /*------------------------------------------------------------------------ Check if station has not been registered in the mean while if not registered, flush cached frames. ------------------------------------------------------------------------*/ pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 == pClientSTA->ucExists ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Station has been deleted for STA %d - flushing cache", ucSTAId)); MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_FLUSH_CACHED_FRAMES, ucSTAId, pClientSTA->tlCacheInfo.cacheSize)); WLANTL_FlushCachedFrames(pClientSTA->vosBegCachedFrame); goto done; } /*------------------------------------------------------------------------ Forwarding cache frames received while the station was in the process of being registered with the rest of the SW components Access to the cache must be locked; similarly updating the signature and the existence flag must be synchronized because these values are checked during cached ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Preparing to fwd packets for STA %d", ucSTAId)); /*----------------------------------------------------------------------- Save the new signature values ------------------------------------------------------------------------*/ pClientSTA->wSTADesc.ucUcastSig = ucUcastSig; pClientSTA->wSTADesc.ucBcastSig = ucBcastSig; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Fwd-ing packets for STA %d UC %d BC %d", ucSTAId, ucUcastSig, ucBcastSig)); /*------------------------------------------------------------------------- Check to see if we have any cached data to forward -------------------------------------------------------------------------*/ if ( NULL != pClientSTA->vosBegCachedFrame ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Fwd-ing Cached packets for station %d", ucSTAId )); WLANTL_RxCachedFrames( pTLCb, ucSTAId, pClientSTA->vosBegCachedFrame); } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: NO cached packets for station %d", ucSTAId )); } done: /*------------------------------------------------------------------------- Clear the station cache -------------------------------------------------------------------------*/ pClientSTA->vosBegCachedFrame = NULL; pClientSTA->vosEndCachedFrame = NULL; pClientSTA->tlCacheInfo.cacheSize = 0; pClientSTA->tlCacheInfo.cacheClearTime = vos_timer_get_system_time(); /*----------------------------------------------------------------------- After all the init is complete we can mark the existance flag ----------------------------------------------------------------------*/ pClientSTA->enableCaching = 0; //WLAN_TL_UNLOCK_STA_CACHE(pTLCb->atlSTAClients[ucSTAId]); return VOS_STATUS_SUCCESS; }/*WLANTL_ForwardSTAFrames*/ #if defined(FEATURE_WLAN_ESE) || defined(FEATURE_WLAN_ESE_UPLOAD) /*========================================================================== FUNCTION WLANTL_IsIAPPFrame DESCRIPTION Internal utility function for detecting incoming ESE IAPP frames DEPENDENCIES PARAMETERS IN pvBDHeader: pointer to the BD header vosTempBuff: the data packet IN/OUT pFirstDataPktArrived: static from caller function; used for rssi computation RETURN VALUE The result code associated with performing the operation VOS_TRUE: It is a IAPP frame VOS_FALSE: It is NOT IAPP frame SIDE EFFECTS ============================================================================*/ v_BOOL_t WLANTL_IsIAPPFrame ( v_PVOID_t pvBDHeader, vos_pkt_t* vosTempBuff ) { v_U16_t usMPDUDOffset; v_U8_t ucOffset; v_U8_t ucSnapHdr[WLANTL_LLC_SNAP_SIZE]; v_SIZE_t usSnapHdrSize = WLANTL_LLC_SNAP_SIZE; VOS_STATUS vosStatus; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Check if OUI field is present. -------------------------------------------------------------------------*/ if ( VOS_FALSE == WDA_IS_RX_LLC_PRESENT(pvBDHeader) ) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:LLC header removed, cannot determine BT-AMP type -" "dropping pkt")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } usMPDUDOffset = (v_U8_t)WDA_GET_RX_MPDU_DATA_OFFSET(pvBDHeader); ucOffset = (v_U8_t)usMPDUDOffset + WLANTL_LLC_SNAP_OFFSET; vosStatus = vos_pkt_extract_data( vosTempBuff, ucOffset, (v_PVOID_t)ucSnapHdr, &usSnapHdrSize); if (( VOS_STATUS_SUCCESS != vosStatus)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Unable to extract Snap Hdr of data packet -" "dropping pkt")); return VOS_FALSE; } /*------------------------------------------------------------------------ Check if this is IAPP frame by matching Aironet Snap hdr. -------------------------------------------------------------------------*/ // Compare returns 1 if values are same and 0 // if not the same. if (( WLANTL_LLC_SNAP_SIZE != usSnapHdrSize ) || ( 0 == vos_mem_compare(ucSnapHdr, (v_PVOID_t)WLANTL_AIRONET_SNAP_HEADER, WLANTL_LLC_SNAP_SIZE ) )) { return VOS_FALSE; } return VOS_TRUE; } #endif //FEATURE_WLAN_ESE /*========================================================================== FUNCTION WLANTL_ProcessBAPFrame DESCRIPTION Internal utility function for processing incoming BT-AMP frames DEPENDENCIES TL must be initiailized before this function gets called. Bothe the BT-AMP station and the BAP Ctrl path must have been previously registered with TL. PARAMETERS IN pvBDHeader: pointer to the BD header vosTempBuff: the data packet pTLCb: TL control block ucSTAId: station id IN/OUT pFirstDataPktArrived: static from caller function; used for rssi computation RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ v_BOOL_t WLANTL_ProcessBAPFrame ( v_PVOID_t pvBDHeader, vos_pkt_t* vosTempBuff, WLANTL_CbType* pTLCb, v_U8_t* pFirstDataPktArrived, v_U8_t ucSTAId ) { v_U16_t usMPDUDOffset; v_U8_t ucOffset; v_U8_t ucOUI[WLANTL_LLC_OUI_SIZE]; v_SIZE_t usOUISize = WLANTL_LLC_OUI_SIZE; VOS_STATUS vosStatus; v_U16_t usType; v_SIZE_t usTypeLen = sizeof(usType); v_U8_t ucMPDUHOffset; v_U8_t ucMPDUHLen = 0; v_U16_t usActualHLen = 0; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Extract OUI and type from LLC and validate; if non-data send to BAP -------------------------------------------------------------------------*/ if ( VOS_FALSE == WDA_IS_RX_LLC_PRESENT(pvBDHeader) ) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:LLC header removed, cannot determine BT-AMP type -" "dropping pkt")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } usMPDUDOffset = (v_U8_t)WDA_GET_RX_MPDU_DATA_OFFSET(pvBDHeader); ucMPDUHOffset = (v_U8_t)WDA_GET_RX_MPDU_HEADER_OFFSET(pvBDHeader); ucMPDUHLen = (v_U8_t)WDA_GET_RX_MPDU_HEADER_LEN(pvBDHeader); ucOffset = (v_U8_t)usMPDUDOffset + WLANTL_LLC_OUI_OFFSET; vosStatus = vos_pkt_extract_data( vosTempBuff, ucOffset, (v_PVOID_t)ucOUI, &usOUISize); #if 0 // Compare returns 1 if values are same and 0 // if not the same. if (( WLANTL_LLC_OUI_SIZE != usOUISize ) || ( 0 == vos_mem_compare(ucOUI, (v_PVOID_t)WLANTL_BT_AMP_OUI, WLANTL_LLC_OUI_SIZE ) )) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "LLC header points to diff OUI in BT-AMP station -" "dropping pkt")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } #endif /*------------------------------------------------------------------------ Extract LLC OUI and ensure that this is indeed a BT-AMP frame ------------------------------------------------------------------------*/ vosStatus = vos_pkt_extract_data( vosTempBuff, ucOffset + WLANTL_LLC_OUI_SIZE, (v_PVOID_t)&usType, &usTypeLen); if (( VOS_STATUS_SUCCESS != vosStatus) || ( sizeof(usType) != usTypeLen )) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Unable to extract type on incoming BAP packet -" "dropping pkt")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } /*------------------------------------------------------------------------ Check if this is BT-AMP data or ctrl packet(RSN, LinkSvision, ActivityR) ------------------------------------------------------------------------*/ usType = vos_be16_to_cpu(usType); if (WLANTL_BAP_IS_NON_DATA_PKT_TYPE(usType)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Non-data packet received over BT-AMP link: %d, => BAP", usType)); /*Flatten packet as BAP expects to be able to peek*/ if ( VOS_STATUS_SUCCESS != vos_pkt_flatten_rx_pkt(&vosTempBuff)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Cannot flatten BT-AMP packet - dropping")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } /* Send packet to BAP client*/ if ( VOS_STATUS_SUCCESS != WDA_DS_TrimRxPacketInfo( vosTempBuff ) ) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:BD header corrupted - dropping packet")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); return VOS_TRUE; } if ( 0 == WDA_GET_RX_FT_DONE(pvBDHeader) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Non-data packet received over BT-AMP link: Sending it for " "frame Translation")); if (usMPDUDOffset > ucMPDUHOffset) { usActualHLen = usMPDUDOffset - ucMPDUHOffset; } /* software frame translation for BTAMP WDS.*/ WLANTL_Translate80211To8023Header( vosTempBuff, &vosStatus, usActualHLen, ucMPDUHLen, pTLCb,ucSTAId, VOS_FALSE); } if (pTLCb->tlBAPClient.pfnTlBAPRx) pTLCb->tlBAPClient.pfnTlBAPRx( vos_get_global_context(VOS_MODULE_ID_TL,pTLCb), vosTempBuff, (WLANTL_BAPFrameEnumType)usType ); else { VOS_ASSERT(0); } return VOS_TRUE; } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: BAP DATA packet received over BT-AMP link: %d, => BAP", usType)); /*!!!FIX ME!!*/ #if 0 /*-------------------------------------------------------------------- For data packet collect phy stats RSSI and Link Quality Calculate the RSSI average and save it. Continuous average is done. --------------------------------------------------------------------*/ if ( *pFirstDataPktArrived == 0) { pTLCb->atlSTAClients[ucSTAId].rssiAvg = WLANHAL_GET_RSSI_AVERAGE( pvBDHeader ); pTLCb->atlSTAClients[ucSTAId].uLinkQualityAvg = WLANHAL_RX_BD_GET_SNR( pvBDHeader ); // Rcvd 1st pkt, start average from next time *pFirstDataPktArrived = 1; } else { pTLCb->atlSTAClients[ucSTAId].rssiAvg = (WLANHAL_GET_RSSI_AVERAGE( pvBDHeader ) + pTLCb->atlSTAClients[ucSTAId].rssiAvg)/2; pTLCb->atlSTAClients[ucSTAId].uLinkQualityAvg = (WLANHAL_RX_BD_GET_SNR( pvBDHeader ) + pTLCb->atlSTAClients[ucSTAId].uLinkQualityAvg)/2; }/*Else, first data packet*/ #endif }/*BT-AMP data packet*/ return VOS_FALSE; }/*WLANTL_ProcessBAPFrame*/ /*========================================================================== FUNCTION WLANTL_ProcessFCFrame DESCRIPTION Internal utility function for processing incoming Flow Control frames. Enable or disable LWM mode based on the information. DEPENDENCIES TL must be initiailized before this function gets called. FW sends up special flow control frame. PARAMETERS IN pvosGCtx pointer to vos global context pvBDHeader: pointer to the BD header pTLCb: TL control block pvBDHeader pointer to BD header. IN/OUT pFirstDataPktArrived: static from caller function; used for rssi computation RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input frame are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS The ingress and egress of each station will be updated. If needed, LWM mode will be enabled or disabled based on the flow control algorithm. ============================================================================*/ v_BOOL_t WLANTL_ProcessFCFrame ( v_PVOID_t pvosGCtx, vos_pkt_t* pvosDataBuff, v_PVOID_t pvBDHeader ) { #if 1 //enable processing of only fcStaTxDisabled bitmap for now. the else part is old better qos code. // need to revisit the old code for full implementation. v_U8_t ucSTAId; v_U16_t ucStaValidBitmap; v_U16_t ucStaTxDisabledBitmap; WLANTL_CbType* pTLCb = NULL; #ifdef TL_DEBUG_FC v_U32_t rxTimeStamp; v_U32_t curTick; #endif /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_SuspendDataTx")); return VOS_STATUS_E_FAULT; } ucStaValidBitmap = WDA_GET_RX_FC_VALID_STA_MASK(pvBDHeader); ucStaTxDisabledBitmap = WDA_GET_RX_FC_STA_TX_DISABLED_BITMAP(pvBDHeader); #ifdef TL_DEBUG_FC rxTimeStamp = WDA_GET_RX_TIMESTAMP(pvBDHeader); /* hard code of MTU_GLOBAL_TIMER_ADDR to calculate the time between generated and processed */ wpalReadRegister(0x03081400+0x1D4, &curTick); TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%ld (%ld-%ld): Disabled %x Valid %x", curTick > rxTimeStamp ? curTick - rxTimeStamp : rxTimeStamp - (0xFFFFFFFF - curTick), curTick, rxTimeStamp, ucStaTxDisabledBitmap, ucStaValidBitmap)); #endif for(ucSTAId = 0; ucStaValidBitmap != 0; ucStaValidBitmap >>=1, ucStaTxDisabledBitmap >>= 1, ucSTAId ++) { if ( (0 == (ucStaValidBitmap & 0x1)) || (pTLCb->atlSTAClients[ucSTAId] && (0 == pTLCb->atlSTAClients[ucSTAId]->ucExists)) ) continue; if (ucStaTxDisabledBitmap & 0x1) { WLANTL_SuspendDataTx(pvosGCtx, &ucSTAId, NULL); } else { WLANTL_ResumeDataTx(pvosGCtx, &ucSTAId); } } #else VOS_STATUS vosStatus; tpHalFcRxBd pvFcRxBd = NULL; v_U8_t ucBitCheck = 0x1; v_U8_t ucStaValid = 0; v_U8_t ucSTAId = 0; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Received FC Response"); if ( (NULL == pTLCb) || (NULL == pvosDataBuff)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid pointer in %s", __func__)); return VOS_STATUS_E_FAULT; } vosStatus = vos_pkt_peek_data( pvosDataBuff, 0, (v_PVOID_t)&pvFcRxBd, sizeof(tHalFcRxBd)); if ( (VOS_STATUS_SUCCESS != vosStatus) || (NULL == pvFcRxBd) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:wrong FC Rx packet")); return VOS_STATUS_E_INVAL; } // need to swap bytes in the FC contents. WLANHAL_SwapFcRxBd(&pvFcRxBd->fcSTATxQLen[0]); //logic to enable/disable LWM mode for each station for( ucStaValid = (v_U8_t)pvFcRxBd->fcSTAValidMask; ucStaValid; ucStaValid >>= 1, ucBitCheck <<= 1, ucSTAId ++) { if ( (0 == (ucStaValid & 0x1)) || (0 == pTLCb->atlSTAClients[ucSTAId].ucExists) ) { continue; } if ( pvFcRxBd->fcSTAThreshIndMask & ucBitCheck ) { //LWM event is reported by FW. Able to fetch more packet if( pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled ) { //Now memory usage is below LWM. Station can send more packets. pTLCb->atlSTAClients[ucSTAId].ucLwmEventReported = TRUE; } else { TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL: FW report LWM event but the station %d is not in LWM mode", ucSTAId)); } } //calculate uEgress_length/uIngress_length only after receiving enough packets if (WLANTL_LWM_INGRESS_SAMPLE_THRESHOLD <= pTLCb->atlSTAClients[ucSTAId].uIngress_length) { //check memory usage info to see whether LWM mode should be enabled for the station v_U32_t uEgress_length = pTLCb->atlSTAClients[ucSTAId].uIngress_length + pTLCb->atlSTAClients[ucSTAId].bmuMemConsumed - pvFcRxBd->fcSTATxQLen[ucSTAId]; //if ((float)uEgress_length/(float)pTLCb->atlSTAClients[ucSTAId].uIngress_length // <= WLANTL_LWM_EGRESS_INGRESS_THRESHOLD) if ( (pTLCb->atlSTAClients[ucSTAId].uIngress_length > uEgress_length) && ((pTLCb->atlSTAClients[ucSTAId].uIngress_length - uEgress_length ) >= (pTLCb->atlSTAClients[ucSTAId].uIngress_length >> 2)) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Enable LWM mode for station %d", ucSTAId)); pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled = TRUE; } else { if( pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Disable LWM mode for station %d", ucSTAId)); pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled = FALSE; } } //remember memory usage in FW starting from this round pTLCb->atlSTAClients[ucSTAId].bmuMemConsumed = pvFcRxBd->fcSTATxQLen[ucSTAId]; pTLCb->atlSTAClients[ucSTAId].uIngress_length = 0; } //(WLANTL_LWM_INGRESS_SAMPLE_THRESHOLD <= pTLCb->atlSTAClients[ucSTAId].uIngress_length) if( pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled ) { //always update current maximum allowed memeory usage pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax = WLANTL_STA_BMU_THRESHOLD_MAX - pvFcRxBd->fcSTATxQLen[ucSTAId]; } } #endif return VOS_STATUS_SUCCESS; } /** * WLANTL_FlowControl() - TX Flow control * @pTLCb: TL context pointer * @pvosDataBuff: Firmware indication data buffer * * This function implenets the algorithm to flow control TX traffic in case * of SAP and SAP + STA concurrency. * * Algorithm goal is to fetch more packets from good peer than bad peer by * introducing weights for each station connected. Weight of each station is * calcutated by taking ratio of max RA rate of the peers to its rate. If the * ratio is less than two based on number of queued frames in the station BTQM * weight is modified. If the queued frames reaches the defined threshold weight * is assigned as four. Here weight is inversely proportional to the number of * packets fetch. * * Return true if flow controlled or false otherwise. */ static bool WLANTL_FlowControl(WLANTL_CbType* pTLCb, vos_pkt_t* pvosDataBuff) { WLANTL_FlowControlInfo *fc_data = NULL; WLANTL_PerStaFlowControlParam *sta_fc_params = NULL; uint8_t num_stas; struct sk_buff *skb = NULL; uint16_t data_len; uint8_t *staid; uint16_t max_rate = 0; uint8_t i; vos_pkt_get_packet_length(pvosDataBuff, &data_len); if (!data_len) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Null fw indication data", __func__)); return false; } vos_pkt_get_os_packet(pvosDataBuff, (v_VOID_t **)&skb, 0); fc_data = (WLANTL_FlowControlInfo *)skb->data; num_stas = fc_data->num_stas; if (!num_stas) { TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s: No connected stations", __func__)); return true; } /* Skip flow control for one connected station */ if (1 == num_stas) return true; staid = (uint8_t *)vos_mem_malloc(WLAN_MAX_STA_COUNT); if (!staid) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: mem allocation failure", __func__)); return false; } vos_mem_set((uint8_t *)staid, WLAN_MAX_STA_COUNT, 0); sta_fc_params = (WLANTL_PerStaFlowControlParam *)(&fc_data->num_stas + 1); for(i = 0; i < num_stas; i ++, sta_fc_params ++) { staid[i] = sta_fc_params->sta_id; if (!pTLCb->atlSTAClients[staid[i]]) continue; pTLCb->atlSTAClients[staid[i]]->per = sta_fc_params->avg_per; pTLCb->atlSTAClients[staid[i]]->queue = sta_fc_params->queue_len; pTLCb->atlSTAClients[staid[i]]->trate = sta_fc_params->rate; max_rate = max_rate > pTLCb->atlSTAClients[staid[i]]->trate ? max_rate : pTLCb->atlSTAClients[staid[i]]->trate; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s: sta_id:%d in:%d queue:%d avg_per:%d rate:%d", __func__, staid[i], pTLCb->atlSTAClients[staid[i]]->tx_samples_sum, pTLCb->atlSTAClients[staid[i]]->queue, pTLCb->atlSTAClients[staid[i]]->per, pTLCb->atlSTAClients[staid[i]]->trate)); } for (i = 0; i < num_stas; i++) { pTLCb->atlSTAClients[staid[i]]->weight = max_rate/pTLCb->atlSTAClients[staid[i]]->trate; if (pTLCb->atlSTAClients[staid[i]]->weight >= WLANTL_RATE_RATIO_THRESHOLD) { if (!pTLCb->atlSTAClients[staid[i]]->set_flag) { vos_set_hdd_bad_sta(staid[i]); pTLCb->atlSTAClients[staid[i]]->set_flag = true; } /** * If station's link becomes very bad rssi below -90dbm then because * of high PER rate high number of packets are stuck in BTQM which is * affecting the good peers throughput. So throttle further the bad * link traffic. */ if ((pTLCb->atlSTAClients[staid[i]]->weight > WLANTL_WEIGHT_THRESHOLD) && (pTLCb->atlSTAClients[staid[i]]->queue > WLANTL_QUEUE_THRESHOLD)) pTLCb->atlSTAClients[staid[i]]->weight *= 2; } if (pTLCb->atlSTAClients[staid[i]]->weight < WLANTL_RATE_RATIO_THRESHOLD) { if (pTLCb->atlSTAClients[staid[i]]->per >= WLANTL_PER_THRESHOLD && pTLCb->atlSTAClients[staid[i]]->queue > WLANTL_QUEUE_THRESHOLD && !pTLCb->atlSTAClients[staid[i]]->set_flag) { pTLCb->atlSTAClients[staid[i]]->weight *= 2; vos_set_hdd_bad_sta(staid[i]); pTLCb->atlSTAClients[staid[i]]->set_flag = true; } else if (pTLCb->atlSTAClients[staid[i]]->set_flag) { vos_reset_hdd_bad_sta(staid[i]); pTLCb->atlSTAClients[staid[i]]->set_flag = false; } } } vos_mem_free(staid); return true; } /** * WLANTL_CacheEapol() - cache eapol frames * @pTLCb : pointer to TL context * @vosTempBuff: pointer to vos packet buff * * Return: None * */ static void WLANTL_CacheEapol(WLANTL_CbType* pTLCb, vos_pkt_t* vosTempBuff) { if ((NULL == pTLCb) || (NULL == vosTempBuff)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid input pointer", __func__)); return; } if (NULL == pTLCb->vosEapolCachedFrame) { TLLOG1(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s: Cache Eapol frame", __func__)); pTLCb->vosEapolCachedFrame = vosTempBuff; } else { TLLOG1(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s: Drop duplicate EAPOL frame", __func__)); vos_pkt_return_packet(vosTempBuff); } } /** * WLANTL_SampleRxRSSI() - Collect RX rssi samples * @pTLCb: TL context pointer * @pBDHeader: RX Meta data pointer * @sta_id: Station ID * * This function records the last twenty RX RSSI samples * * Return: void */ static void WLANTL_SampleRxRSSI(WLANTL_CbType* pTLCb, void * pBDHeader, uint8_t sta_id) { uint8_t count; uint8_t old_idx; s8 curr_RSSI, curr_RSSI0, curr_RSSI1; WLANTL_STAClientType *pClientSTA = pTLCb->atlSTAClients[sta_id]; if(pClientSTA == NULL) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s: pClientSTA is NULL", __func__)); return; } count = pClientSTA->rssi_sample_cnt; old_idx = pClientSTA->rssi_stale_idx; curr_RSSI0 = WLANTL_GETRSSI0(pBDHeader); curr_RSSI1 = WLANTL_GETRSSI1(pBDHeader); curr_RSSI = (curr_RSSI0 > curr_RSSI1) ? curr_RSSI0 : curr_RSSI1; if (count >= WLANTL_RSSI_SAMPLE_CNT) { pClientSTA->rssi_sample_sum -= pClientSTA->rssi_sample[old_idx]; pClientSTA->rssi_sample[old_idx] = curr_RSSI; pClientSTA->rssi_sample_sum += pClientSTA->rssi_sample[old_idx]; old_idx >= (WLANTL_RSSI_SAMPLE_CNT - 1) ? old_idx = 0 : old_idx++; pClientSTA->rssi_stale_idx = old_idx; } else { pClientSTA->rssi_sample[count] = curr_RSSI; pClientSTA->rssi_sample_sum += pClientSTA->rssi_sample[count]; pClientSTA->rssi_sample_cnt++; } } /** * WLANTL_StaMonRX - Send packets to monitor mode * @pTLCb: TL context pointer * @pFrame: Rx buffer pointer * @pBDHeader: RX Meta data pointer * @sta_id: Station ID * * Return: true if RX monitor mode or false otherwise */ static bool WLANTL_StaMonRX(WLANTL_CbType* pTLCb, vos_pkt_t *pFrame, WDI_DS_RxMetaInfoType *pRxMetadata, uint8_t sta_id) { WLANTL_STAClientType *pClientSTA = NULL; tpSirMacMgmtHdr pHdr = NULL; v_MACADDR_t *peerMacAddr = NULL; uint8_t i = 0; uint8_t addr1_index = WDA_GET_RX_ADDR1_IDX(pRxMetadata); bool tp_data = false; pHdr = (tpSirMacMgmtHdr)pRxMetadata->mpduHeaderPtr; peerMacAddr = (v_MACADDR_t *)pHdr->da; if (vos_check_monitor_state() == false) return false; if ((addr1_index == 254) && WLANTL_IS_DATA_FRAME(WDA_GET_RX_TYPE_SUBTYPE(pRxMetadata)) && !pRxMetadata->bcast) { tp_data = true; } else if (WLANTL_STA_ID_MONIFACE(sta_id) == 0) { return false; } if (WLANTL_IS_MGMT_FRAME(WDA_GET_RX_TYPE_SUBTYPE(pRxMetadata)) || tp_data) { if (pRxMetadata->bcast) return false; for (i = 0; i < WLAN_MAX_STA_COUNT; i++) { if (NULL == pTLCb->atlSTAClients[i]) continue; if (0 == pTLCb->atlSTAClients[i]->ucExists) continue; if (WLANTL_STA_AUTHENTICATED == pTLCb->atlSTAClients[i]->tlState) break; } if (i == WLAN_MAX_STA_COUNT) { if (tp_data) return true; return false; } pClientSTA = pTLCb->atlSTAClients[i]; if (vos_is_macaddr_equal(peerMacAddr, &pClientSTA->wSTADesc.vSelfMACAddress)) return false; if (vos_is_macaddr_equal(peerMacAddr, &pTLCb->spoofMacAddr.spoofMac) && !tp_data) return false; } return true; } /*========================================================================== FUNCTION WLANTL_RxFrames DESCRIPTION Callback registered by TL and called by BAL when a packet is received over the bus. Upon the call of this function TL will make the necessary decision with regards to the forwarding or queuing of this packet and the layer it needs to be delivered to. DEPENDENCIES TL must be initiailized before this function gets called. If the frame carried is a data frame then the station for which it is destined to must have been previously registered with TL. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or BAL's control block can be extracted from its context vosDataBuff: it will contain a pointer to the first buffer received, if there is more then one packet they will be chained using vOSS buffers. RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RxFrames ( v_PVOID_t pvosGCtx, vos_pkt_t *pFrameDataBuff ) { vos_pkt_t* vosDataBuff = (vos_pkt_t*)pFrameDataBuff; WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; WLANTL_STAFuncType pfnSTAFsm; vos_pkt_t* vosTempBuff; v_U8_t ucSTAId; VOS_STATUS vosStatus; v_U8_t ucFrmType; v_PVOID_t pvBDHeader = NULL; WLANTL_STAEventType wSTAEvent = WLANTL_RX_EVENT; v_U8_t ucTid = 0; v_BOOL_t broadcast = VOS_FALSE; v_BOOL_t selfBcastLoopback = VOS_FALSE; static v_U8_t first_data_pkt_arrived; v_U32_t uDPUSig; v_U16_t usPktLen; v_BOOL_t bForwardIAPPwithLLC = VOS_FALSE; #ifdef WLAN_FEATURE_LINK_LAYER_STATS v_S7_t currentAvgRSSI = 0; v_U8_t ac; #endif uint8_t ucMPDUHLen; uint16_t seq_no; u64 pn_num; uint16_t usEtherType = 0; bool sta_mon_data = false; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:TL Receive Frames called")); /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == vosDataBuff ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RxFrames")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Popolaute timestamp as the time when packet arrives ---------------------------------------------------------------------- */ vosDataBuff->timestamp = vos_timer_get_system_ticks(); /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } /*--------------------------------------------------------------------- Save the initial buffer - this is the first received buffer ---------------------------------------------------------------------*/ vosTempBuff = vosDataBuff; while (NULL != vosDataBuff) { broadcast = VOS_FALSE; selfBcastLoopback = VOS_FALSE; vos_pkt_walk_packet_chain( vosDataBuff, &vosDataBuff, 1/*true*/ ); /*--------------------------------------------------------------------- Peek at BD header - do not remove !!! Optimize me: only part of header is needed; not entire one ---------------------------------------------------------------------*/ vosStatus = WDA_DS_PeekRxPacketInfo( vosTempBuff, (v_PVOID_t)&pvBDHeader, 1/*Swap BD*/ ); if ( NULL == pvBDHeader ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot extract BD header")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } /*--------------------------------------------------------------------- Check if frame is for monitor interface ---------------------------------------------------------------------*/ ucSTAId = (v_U8_t)WDA_GET_RX_STAID(pvBDHeader); sta_mon_data = WLANTL_StaMonRX(pTLCb, vosTempBuff, pvBDHeader, ucSTAId); if (vos_get_conparam() == VOS_MONITOR_MODE || sta_mon_data) { sta_mon_data = false; if( pTLCb->isConversionReq ) WLANTL_MonTranslate80211To8023Header(vosTempBuff, pTLCb); pTLCb->pfnMonRx(pvosGCtx, vosTempBuff, pTLCb->isConversionReq); vosTempBuff = vosDataBuff; continue; } /*--------------------------------------------------------------------- Check if FC frame reported from FW ---------------------------------------------------------------------*/ if(WDA_IS_RX_FC(pvBDHeader)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:receive one FC frame")); WLANTL_FlowControl(pTLCb, vosTempBuff); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } /* AMSDU HW bug fix * After 2nd AMSDU subframe HW could not handle BD correctly * HAL workaround is needed */ if(WDA_GET_RX_ASF(pvBDHeader)) { WDA_DS_RxAmsduBdFix(pvosGCtx, pvBDHeader); } /*--------------------------------------------------------------------- Extract frame control field from 802.11 header if present (frame translation not done) ---------------------------------------------------------------------*/ vosStatus = WDA_DS_GetFrameTypeSubType( pvosGCtx, vosTempBuff, pvBDHeader, &ucFrmType ); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot extract Frame Control Field")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } vos_pkt_get_packet_length(vosTempBuff, &usPktLen); /*--------------------------------------------------------------------- Check if management and send to PE ---------------------------------------------------------------------*/ if ( WLANTL_IS_MGMT_FRAME(ucFrmType)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Sending packet to management client")); if ( VOS_STATUS_SUCCESS != vos_pkt_flatten_rx_pkt(&vosTempBuff)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot flatten packet - dropping")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } ucSTAId = (v_U8_t)WDA_GET_RX_STAID( pvBDHeader ); /* Read RSSI and update */ if(!WLANTL_STA_ID_INVALID(ucSTAId)) { #if defined WLAN_FEATURE_NEIGHBOR_ROAMING /* Read RSSI and update */ vosStatus = WLANTL_HSHandleRXFrame(pvosGCtx, WLANTL_MGMT_FRAME_TYPE, pvBDHeader, ucSTAId, VOS_FALSE, NULL); #else vosStatus = WLANTL_ReadRSSI(pvosGCtx, pvBDHeader, ucSTAId); #endif if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGW(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Handle RX Management Frame fail within Handoff " "support module")); /* Do Not Drop packet at here * Revisit why HO module return fail * vos_pkt_return_packet(vosTempBuff); * vosTempBuff = vosDataBuff; * continue; */ } vosStatus = WLANTL_ReadSNR(pvosGCtx, pvBDHeader, ucSTAId); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGW(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, FL("Failed to Read SNR"))); } #ifdef WLAN_FEATURE_LINK_LAYER_STATS pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL != pClientSTA) { pClientSTA->interfaceStats.mgmtRx++; } #endif WLANTL_SampleRxRSSI(pTLCb, pvBDHeader, ucSTAId); } pTLCb->tlMgmtFrmClient.pfnTlMgmtFrmRx( pvosGCtx, vosTempBuff); } else /* Data Frame */ { ucSTAId = (v_U8_t)WDA_GET_RX_STAID( pvBDHeader ); ucTid = (v_U8_t)WDA_GET_RX_TID( pvBDHeader ); uDPUSig = WDA_GET_RX_DPUSIG(pvBDHeader); ucMPDUHLen = (uint8_t)WDA_GET_RX_MPDU_HEADER_LEN(pvBDHeader); seq_no = (uint16_t)WDA_GET_RX_REORDER_CUR_PKT_SEQ_NO(pvBDHeader); pn_num = WDA_GET_RX_REPLAY_COUNT(pvBDHeader); vosTempBuff->pn_replay_skip = 0; vosTempBuff->pn_num = pn_num; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Data packet received for STA %d", ucSTAId)); /*------------------------------------------------------------------ This should be corrected when multipe sta support is added !!! for now bcast frames will be sent to the last registered STA ------------------------------------------------------------------*/ if ( WDA_IS_RX_BCAST(pvBDHeader)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:TL rx Bcast frame - sending to last registered station")); broadcast = VOS_TRUE; /*------------------------------------------------------------------- If Addr1 is b/mcast, but Addr3 is our own self MAC, it is a b/mcast pkt we sent looping back to us. To be dropped if we are non BTAMP -------------------------------------------------------------------*/ if( WLANHAL_RX_BD_ADDR3_SELF_IDX == (v_U8_t)WDA_GET_RX_ADDR3_IDX( pvBDHeader )) { selfBcastLoopback = VOS_TRUE; } }/*if bcast*/ /* Pre assoc cache eapol */ if (pTLCb->preassoc_caching) { WLANTL_GetEtherType(pvBDHeader,vosTempBuff, ucMPDUHLen, &usEtherType); if (WLANTL_LLC_8021X_TYPE != usEtherType) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s: RX Frame not EAPOL EtherType %d", __func__, usEtherType); vos_pkt_return_packet(vosTempBuff); } else { WLANTL_CacheEapol(pTLCb, vosTempBuff); TLLOG1(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:TL preassoc_caching is enabled seq No: %d", seq_no)); } vosTempBuff = vosDataBuff; continue; } if (WLANTL_STA_ID_INVALID(ucSTAId)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:STAId %d. Invalid STA ID dropping pkt", ucSTAId)); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } if (WLANTL_TID_INVALID( ucTid)) { /* There is a possibility AP uses wrong TID. In that case to avoid dropping EAPOL packet in the driver use TID to zero.*/ VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:Invalid Tid: %d Frame type: %d", ucTid, ucFrmType); WDA_GET_RX_TID( pvBDHeader ) = 0; ucTid = 0; } #ifdef WLAN_FEATURE_LINK_LAYER_STATS ac = WLANTL_TID_2_AC[ucTid]; #endif /*---------------------------------------------------------------------- No need to lock cache access because cache manipulation only happens in the transport thread/task context - These frames are to be forwarded to the station upon registration which happens in the main thread context The caching here can happen in either Tx or Rx thread depending on the current SSC scheduling - also we need to make sure that the frames in the cache are fwd-ed to the station before the new incoming ones -----------------------------------------------------------------------*/ pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if (NULL == pClientSTA) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:STA not allocated memory. Dropping packet")); vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } #ifdef FEATURE_WLAN_TDLS if (( pClientSTA->ucExists ) && (WLAN_STA_TDLS == pClientSTA->wSTADesc.wSTAType) && (pClientSTA->ucTxSuspended)) vos_atomic_set_U8( &pClientSTA->ucTxSuspended, 0 ); else if ( !broadcast && (pClientSTA->ucExists == 0 ) ) { tpSirMacMgmtHdr pMacHeader = WDA_GET_RX_MAC_HEADER( pvBDHeader ); /* from the direct peer while it is not registered to TL yet */ if ( (pMacHeader->fc.fromDS == 0) && (pMacHeader->fc.toDS == 0) ) { v_U8_t ucAddr3STAId; ucAddr3STAId = WDA_GET_RX_ADDR3_IDX(pvBDHeader); if ( WLANTL_STA_ID_INVALID(ucAddr3STAId) ) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:STA ID %d invalid - dropping pkt", ucAddr3STAId)); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } if (!(pTLCb->atlSTAClients[ucAddr3STAId] && pTLCb->atlSTAClients[ucAddr3STAId]->ucExists && (WLAN_STA_INFRA == pTLCb->atlSTAClients[ucAddr3STAId]->wSTADesc.wSTAType) && (WLANTL_STA_AUTHENTICATED == pTLCb->atlSTAClients[ucAddr3STAId]->tlState))) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "%s: staId %d addr3Id %d tlState %d. Unkown Receiver/Transmitter Dropping packet", __func__, ucSTAId, ucAddr3STAId, pTLCb->atlSTAClients[ucAddr3STAId]->tlState)); vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } else { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_DEBUG, "staId %d doesn't exist" " but mapped to AP staId %d PN:[0x%llX]", ucSTAId, ucAddr3STAId, pn_num); ucSTAId = ucAddr3STAId; pClientSTA = pTLCb->atlSTAClients[ucAddr3STAId]; vosTempBuff->pn_replay_skip = 1; } } } #endif if (( pClientSTA->enableCaching == 1 ) && /*Dont buffer Broadcast/Multicast frames. If AP transmits bursts of Broadcast/Multicast data frames, * libra buffers all Broadcast/Multicast packets after authentication with AP, * So it will lead to low resource condition in Rx Data Path.*/ ( WDA_IS_RX_BCAST(pvBDHeader) == 0 )) { if( WDA_IsSelfSTA(pvosGCtx,ucSTAId)) { //drop packet for Self STA index TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "%s: Packet dropped for Self STA with staId %d ", __func__, ucSTAId )); vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } /* Station has not yet been registered with TL - cache the frame */ TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "%s: staId %d exist %d tlState %d cache rx frame", __func__, ucSTAId, pClientSTA->ucExists, pClientSTA->tlState)); WLANTL_CacheSTAFrame( pTLCb, ucSTAId, vosTempBuff, uDPUSig, broadcast, ucFrmType); vosTempBuff = vosDataBuff; continue; } #ifdef FEATURE_WLAN_ESE_UPLOAD if ((pClientSTA->wSTADesc.ucIsEseSta)|| broadcast) { /*-------------------------------------------------------------------- Filter the IAPP frames for ESE connection; if data it will return false and it will be routed through the regular data path --------------------------------------------------------------------*/ if ( WLANTL_IsIAPPFrame(pvBDHeader, vosTempBuff)) { bForwardIAPPwithLLC = VOS_TRUE; } } #endif #if defined(FEATURE_WLAN_ESE) && !defined(FEATURE_WLAN_ESE_UPLOAD) if ((pClientSTA->wSTADesc.ucIsEseSta)|| broadcast) { /*-------------------------------------------------------------------- Filter the IAPP frames for ESE connection; if data it will return false and it will be routed through the regular data path --------------------------------------------------------------------*/ if ( WLANTL_IsIAPPFrame(pvBDHeader, vosTempBuff)) { if ( VOS_STATUS_SUCCESS != vos_pkt_flatten_rx_pkt(&vosTempBuff)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot flatten packet - dropping")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); } else { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Received ESE IAPP Frame")); pTLCb->tlMgmtFrmClient.pfnTlMgmtFrmRx( pvosGCtx, vosTempBuff); } vosTempBuff = vosDataBuff; continue; } } #endif /* defined(FEATURE_WLAN_ESE) && !defined(FEATURE_WLAN_ESE_UPLOAD) */ if ( WLAN_STA_BT_AMP == pClientSTA->wSTADesc.wSTAType ) { /*-------------------------------------------------------------------- Process the ctrl BAP frame; if data it will return false and it will be routed through the regular data path --------------------------------------------------------------------*/ if ( WLANTL_ProcessBAPFrame( pvBDHeader, vosTempBuff, pTLCb, &first_data_pkt_arrived, ucSTAId)) { vosTempBuff = vosDataBuff; continue; } }/*if BT-AMP station*/ else if(selfBcastLoopback == VOS_TRUE) { /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } /*--------------------------------------------------------------------- Data packet received, send to state machine ---------------------------------------------------------------------*/ wSTAEvent = WLANTL_RX_EVENT; pfnSTAFsm = tlSTAFsm[pClientSTA->tlState]. pfnSTATbl[wSTAEvent]; if ( NULL != pfnSTAFsm ) { #if defined WLAN_FEATURE_NEIGHBOR_ROAMING /* Read RSSI and update */ vosStatus = WLANTL_HSHandleRXFrame(pvosGCtx, WLANTL_DATA_FRAME_TYPE, pvBDHeader, ucSTAId, broadcast, vosTempBuff); broadcast = VOS_FALSE; #else vosStatus = WLANTL_ReadRSSI(pvosGCtx, pvBDHeader, ucSTAId); #endif if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Handle RX Data Frame fail within Handoff support module")); /* Do Not Drop packet at here * Revisit why HO module return fail * vos_pkt_return_packet(vosTempBuff); * vosTempBuff = vosDataBuff; * continue; */ } #ifdef WLAN_FEATURE_LINK_LAYER_STATS pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL != pClientSTA) { tpSirMacMgmtHdr pMacHeader = WDA_GET_RX_MAC_HEADER( pvBDHeader ); if (!IS_BROADCAST_ADD(pMacHeader->da) && IS_MULTICAST_ADD(pMacHeader->da)) { pClientSTA->interfaceStats.accessCategoryStats[ac].rxMcast++; } WLANTL_HSGetDataRSSI(pvosGCtx, pvBDHeader, ucSTAId, ¤tAvgRSSI); pClientSTA->interfaceStats.rssiData = currentAvgRSSI; pClientSTA->interfaceStats.accessCategoryStats[ac].rxMpdu++; if (WDA_IS_RX_AN_AMPDU (pvBDHeader)) { pClientSTA->interfaceStats.accessCategoryStats[ac].rxAmpdu++; } } #endif vosStatus = WLANTL_ReadSNR(pvosGCtx, pvBDHeader, ucSTAId); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGW(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, FL("Failed to Read SNR"))); } WLANTL_SampleRxRSSI(pTLCb, pvBDHeader, ucSTAId); pfnSTAFsm( pvosGCtx, ucSTAId, &vosTempBuff, bForwardIAPPwithLLC); } else { TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:NULL state function, STA:%d, State: %d- dropping packet", ucSTAId, pClientSTA->tlState)); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } }/* else data frame*/ vosTempBuff = vosDataBuff; }/*while chain*/ return VOS_STATUS_SUCCESS; }/* WLANTL_RxFrames */ #ifdef WLAN_FEATURE_LINK_LAYER_STATS /*========================================================================== FUNCTION WLANTL_CollectInterfaceStats DESCRIPTION Utility function used by TL to send the statitics DEPENDENCIES PARAMETERS IN ucSTAId: station for which the statistics need to collected vosDataBuff: it will contain the pointer to the corresponding structure RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_CollectInterfaceStats ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_InterfaceStatsType *vosDataBuff ) { WLANTL_CbType* pTLCb = NULL; /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_CollectStats")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_CollectStats")); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: collect WIFI_STATS_IFACE results")); vos_mem_copy(vosDataBuff, &pTLCb->atlSTAClients[ucSTAId]->interfaceStats, sizeof(WLANTL_InterfaceStatsType)); return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION WLANTL_ClearInterfaceStats DESCRIPTION Utility function used by TL to clear the statitics DEPENDENCIES PARAMETERS IN ucSTAId: station for which the statistics need to collected RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ClearInterfaceStats ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U8_t statsClearReqMask ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested on WLANTL_CollectStats")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_CollectStats")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ((statsClearReqMask & WIFI_STATS_IFACE_AC) || (statsClearReqMask & WIFI_STATS_IFACE)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:cleared WIFI_STATS_IFACE_AC results")); pClientSTA->interfaceStats.accessCategoryStats[0].rxMcast = 0; pClientSTA->interfaceStats.accessCategoryStats[1].rxMcast = 0; pClientSTA->interfaceStats.accessCategoryStats[2].rxMcast = 0; pClientSTA->interfaceStats.accessCategoryStats[3].rxMcast = 0; pClientSTA->interfaceStats.accessCategoryStats[0].rxMpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[1].rxMpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[2].rxMpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[3].rxMpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[0].rxAmpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[1].rxAmpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[2].rxAmpdu = 0; pClientSTA->interfaceStats.accessCategoryStats[3].rxAmpdu = 0; } if (statsClearReqMask & WIFI_STATS_IFACE) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:cleared WIFI_STATS_IFACE results")); pClientSTA->interfaceStats.mgmtRx = 0; pClientSTA->interfaceStats.rssiData = 0; return VOS_STATUS_SUCCESS; } return VOS_STATUS_SUCCESS; } #endif /* WLAN_FEATURE_LINK_LAYER_STATS */ /*========================================================================== FUNCTION WLANTL_RxCachedFrames DESCRIPTION Utility function used by TL to forward the cached frames to a particular station; DEPENDENCIES TL must be initiailized before this function gets called. If the frame carried is a data frame then the station for which it is destined to must have been previously registered with TL. PARAMETERS IN pTLCb: pointer to TL handle ucSTAId: station for which we need to forward the packets vosDataBuff: it will contain a pointer to the first cached buffer received, if there is more then one packet they will be chained using vOSS buffers. RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RxCachedFrames ( WLANTL_CbType* pTLCb, v_U8_t ucSTAId, vos_pkt_t* vosDataBuff ) { WLANTL_STAClientType* pClientSTA = NULL; WLANTL_STAFuncType pfnSTAFsm; vos_pkt_t* vosTempBuff; VOS_STATUS vosStatus; v_PVOID_t pvBDHeader = NULL; WLANTL_STAEventType wSTAEvent = WLANTL_RX_EVENT; v_U8_t ucTid = 0; v_BOOL_t broadcast = VOS_FALSE; v_BOOL_t bSigMatch = VOS_FALSE; v_BOOL_t selfBcastLoopback = VOS_FALSE; static v_U8_t first_data_pkt_arrived; v_U32_t uDPUSig; v_U8_t ucUcastSig; v_U8_t ucBcastSig; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:TL Receive Cached Frames called")); /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == vosDataBuff ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RxFrames")); return VOS_STATUS_E_INVAL; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_FORWARD_CACHED_FRAMES, ucSTAId, 1<<16 | pClientSTA->tlCacheInfo.cacheSize)); /*--------------------------------------------------------------------- Save the initial buffer - this is the first received buffer ---------------------------------------------------------------------*/ vosTempBuff = vosDataBuff; while ( NULL != vosTempBuff ) { broadcast = VOS_FALSE; selfBcastLoopback = VOS_FALSE; vos_pkt_walk_packet_chain( vosDataBuff, &vosDataBuff, 1/*true*/ ); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Sending new cached packet to station %d", ucSTAId)); /*--------------------------------------------------------------------- Peek at BD header - do not remove !!! Optimize me: only part of header is needed; not entire one ---------------------------------------------------------------------*/ vosStatus = WDA_DS_PeekRxPacketInfo( vosTempBuff, (v_PVOID_t)&pvBDHeader, 0 ); if ( NULL == pvBDHeader ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot extract BD header")); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } uDPUSig = WDA_GET_RX_DPUSIG( pvBDHeader ); /* AMSDU HW bug fix * After 2nd AMSDU subframe HW could not handle BD correctly * HAL workaround is needed */ if(WDA_GET_RX_ASF(pvBDHeader)) { WDA_DS_RxAmsduBdFix(vos_get_global_context(VOS_MODULE_ID_TL,pTLCb), pvBDHeader); } ucTid = (v_U8_t)WDA_GET_RX_TID( pvBDHeader ); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Data packet cached for STA %d", ucSTAId); /*------------------------------------------------------------------ This should be corrected when multipe sta support is added !!! for now bcast frames will be sent to the last registered STA ------------------------------------------------------------------*/ if ( WDA_IS_RX_BCAST(pvBDHeader)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:TL rx Bcast frame ")); broadcast = VOS_TRUE; /* If Addr1 is b/mcast, but Addr3 is our own self MAC, it is a b/mcast * pkt we sent looping back to us. To be dropped if we are non BTAMP */ if( WLANHAL_RX_BD_ADDR3_SELF_IDX == (v_U8_t)WDA_GET_RX_ADDR3_IDX( pvBDHeader )) { selfBcastLoopback = VOS_TRUE; } }/*if bcast*/ /*------------------------------------------------------------------------- Check if the packet that we cached matches the DPU signature of the newly added station -------------------------------------------------------------------------*/ pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( broadcast ) { ucBcastSig = (v_U8_t)uDPUSig; bSigMatch = (( WLAN_TL_INVALID_B_SIG != pClientSTA->wSTADesc.ucBcastSig ) && ( ucBcastSig == pClientSTA->wSTADesc.ucBcastSig )); } else { ucUcastSig = (v_U8_t)uDPUSig; bSigMatch = (( WLAN_TL_INVALID_U_SIG != pClientSTA->wSTADesc.ucUcastSig ) && ( ucUcastSig == pClientSTA->wSTADesc.ucUcastSig )); } /*------------------------------------------------------------------------- If the packet doesn't match - drop it -------------------------------------------------------------------------*/ if ( !bSigMatch ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_MED, "WLAN TL: Cached packet does not match DPU Sig of the new STA - drop " " DPU Sig %d UC %d BC %d B %d", uDPUSig, pClientSTA->wSTADesc.ucUcastSig, pClientSTA->wSTADesc.ucBcastSig, broadcast)); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; }/*if signature mismatch*/ /*------------------------------------------------------------------------ Check if BT-AMP frame: - additional processing needed in this case to separate BT-AMP date from BT-AMP Ctrl path ------------------------------------------------------------------------*/ if ( WLAN_STA_BT_AMP == pClientSTA->wSTADesc.wSTAType ) { /*-------------------------------------------------------------------- Process the ctrl BAP frame; if data it will return false and it will be routed through the regular data path --------------------------------------------------------------------*/ if ( WLANTL_ProcessBAPFrame( pvBDHeader, vosTempBuff, pTLCb, &first_data_pkt_arrived, ucSTAId)) { vosTempBuff = vosDataBuff; continue; } }/*if BT-AMP station*/ else if(selfBcastLoopback == VOS_TRUE) { /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } /*--------------------------------------------------------------------- Data packet received, send to state machine ---------------------------------------------------------------------*/ wSTAEvent = WLANTL_RX_EVENT; pfnSTAFsm = tlSTAFsm[pClientSTA->tlState]. pfnSTATbl[wSTAEvent]; if ( NULL != pfnSTAFsm ) { #if defined WLAN_FEATURE_NEIGHBOR_ROAMING /* Read RSSI and update */ vosStatus = WLANTL_HSHandleRXFrame(vos_get_global_context( VOS_MODULE_ID_TL,pTLCb), WLANTL_DATA_FRAME_TYPE, pvBDHeader, ucSTAId, broadcast, vosTempBuff); broadcast = VOS_FALSE; #else vosStatus = WLANTL_ReadRSSI(vos_get_global_context(VOS_MODULE_ID_TL,pTLCb), pvBDHeader, ucSTAId); #endif if(!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Handle RX Data Frame fail within Handoff support module")); /* Do Not Drop packet at here * Revisit why HO module return fail vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; */ } pfnSTAFsm( vos_get_global_context(VOS_MODULE_ID_TL,pTLCb), ucSTAId, &vosTempBuff, VOS_FALSE); } else { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:NULL state function, STA:%d, State: %d- dropping packet", ucSTAId, pClientSTA->tlState)); /* Drop packet */ vos_pkt_return_packet(vosTempBuff); vosTempBuff = vosDataBuff; continue; } vosTempBuff = vosDataBuff; }/*while chain*/ return VOS_STATUS_SUCCESS; }/* WLANTL_RxCachedFrames */ /** * WLANTL_ForwardPkts() - forward cached eapol frames * @pvosGCtx: pointer to vos global context * @data: value to indicate either forward or flush * * Return: None * */ static VOS_STATUS WLANTL_ForwardPkts(void* pvosGCtx, uint32_t data) { WLANTL_CbType* pTLCb = NULL; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid input pointer", __func__)); return VOS_STATUS_E_FAULT; } if (!data) { TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s: Pre assoc fail flush cache", __func__)); WLANTL_FlushCachedFrames(pTLCb->vosEapolCachedFrame); goto done; } /* forward packets to HDD */ if (NULL != pTLCb->vosEapolCachedFrame) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s: forward pre assoc cached frames", __func__)); WLANTL_MonTranslate80211To8023Header(pTLCb->vosEapolCachedFrame, pTLCb); pTLCb->pfnEapolFwd(pvosGCtx, pTLCb->vosEapolCachedFrame); } done: pTLCb->vosEapolCachedFrame = NULL; pTLCb->preassoc_caching = false; return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION WLANTL_RxProcessMsg DESCRIPTION Called by VOSS when a message was serialized for TL through the rx thread/task. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context message: type and content of the message RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other values can be returned as a result of a function call, please check corresponding API for more info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_RxProcessMsg ( v_PVOID_t pvosGCtx, vos_msg_t* message ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_U32_t uData; v_U8_t ucSTAId; v_U8_t ucUcastSig; v_U8_t ucBcastSig; /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == message ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_RxProcessMessage")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Process message ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Received message: %d through rx flow", message->type)); switch( message->type ) { case WLANTL_RX_FWD_CACHED: /*--------------------------------------------------------------------- The data sent with the message has the following structure: | 00 | ucBcastSignature | ucUcastSignature | ucSTAID | each field above is one byte ---------------------------------------------------------------------*/ uData = message->bodyval; ucSTAId = ( uData & 0x000000FF); ucUcastSig = ( uData & 0x0000FF00)>>8; ucBcastSig = (v_U8_t)(( uData & 0x00FF0000)>>16); vosStatus = WLANTL_ForwardSTAFrames( pvosGCtx, ucSTAId, ucUcastSig, ucBcastSig); break; case WLANTL_RX_FWD_PRE_ASSOC_CACHED: uData = message->bodyval; vosStatus = WLANTL_ForwardPkts(pvosGCtx, uData); break; default: /*no processing for now*/ break; } return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION WLANTL_ResourceCB DESCRIPTION Called by the TL when it has packets available for transmission. DEPENDENCIES The TL must be registered with BAL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or BAL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_ResourceCB ( v_PVOID_t pvosGCtx, v_U32_t uCount ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } pTLCb->uResCount = uCount; /*----------------------------------------------------------------------- Resume Tx if enough res and not suspended -----------------------------------------------------------------------*/ if (( pTLCb->uResCount >= WDA_TLI_MIN_RES_MF ) && ( 0 == pTLCb->ucTxSuspended )) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Issuing Xmit start request to BAL for avail res ASYNC")); return WDA_DS_StartXmit(pvosGCtx); } return VOS_STATUS_SUCCESS; }/* WLANTL_ResourceCB */ /*========================================================================== FUNCTION WLANTL_IsTxXmitPending DESCRIPTION Called by the WDA when it wants to know whether WDA_DS_TX_START_XMIT msg is pending in TL msg queue DEPENDENCIES The TL must be registered with WDA before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation 0: No WDA_DS_TX_START_XMIT msg pending 1: Msg WDA_DS_TX_START_XMIT already pending in TL msg queue SIDE EFFECTS ============================================================================*/ v_BOOL_t WLANTL_IsTxXmitPending ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Invalid TL pointer from pvosGCtx in WLANTL_IsTxXmitPending ")); return FALSE; } return pTLCb->isTxTranmitMsgPending; }/*WLANTL_IsTxXmitPending */ /*========================================================================== FUNCTION WLANTL_SetTxXmitPending DESCRIPTION Called by the WDA when it wants to indicate that WDA_DS_TX_START_XMIT msg is pending in TL msg queue DEPENDENCIES The TL must be registered with WDA before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_SetTxXmitPending ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Invalid TL pointer from pvosGCtx in WLANTL_SetTxXmitPending")); return; } pTLCb->isTxTranmitMsgPending = 1; return; }/*WLANTL_SetTxXmitPending */ /*========================================================================== FUNCTION WLANTL_ClearTxXmitPending DESCRIPTION Called by the WDA when it wants to indicate that no WDA_DS_TX_START_XMIT msg is pending in TL msg queue DEPENDENCIES The TL must be registered with WDA before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_ClearTxXmitPending ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Invalid TL pointer from pvosGCtx in WLANTL_ClearTxXmitPending ")); return; } pTLCb->isTxTranmitMsgPending = 0; return; }/*WLANTL_ClearTxXmitPending */ /*========================================================================== FUNCTION WLANTL_TxThreadDebugHandler DESCRIPTION Printing TL Snapshot dump, processed under TxThread context, currently information regarding the global TlCb struture. Dumps information related to per active STA connection currently in use by TL. DEPENDENCIES The TL must be initialized before this gets called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_TxThreadDebugHandler ( v_PVOID_t *pVosContext ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; int i = 0; v_U8_t uFlowMask; // TX FlowMask from WDA TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL: %s Enter ", __func__)); pTLCb = VOS_GET_TL_CB(pVosContext); if ( NULL == pVosContext || NULL == pTLCb ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Global VoS Context or TL Context are NULL")); return; } if (VOS_STATUS_SUCCESS == WDA_DS_GetTxFlowMask(pVosContext, &uFlowMask)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WDA uTxFlowMask: 0x%x", uFlowMask)); } TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "************************TL DUMP INFORMATION**************")); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "uDelayedTriggerFrmInt:%d\tuMinFramesProcThres:%d", pTLCb->tlConfigInfo.uDelayedTriggerFrmInt, pTLCb->tlConfigInfo.uMinFramesProcThres)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Management Frame Client exists: %d", pTLCb->tlMgmtFrmClient.ucExists)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "usPendingTxCompleteCount: %d\tucTxSuspended: %d", pTLCb->usPendingTxCompleteCount, pTLCb->ucTxSuspended)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "uResCount: %d", pTLCb->uResCount)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "ucRegisteredStaId: %d\tucCurrentSTA: %d", pTLCb->ucRegisteredStaId, pTLCb->ucCurrentSTA)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "UrgentFrameProcessing: %s\tuFramesProcThres: %d", (pTLCb->bUrgent?"True":"False"), pTLCb->uFramesProcThres)); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "isTxTranmitMsgPending: %d\t isBMPS: %s", pTLCb->isTxTranmitMsgPending, pTLCb->isBMPS?"True":"False")); #ifdef FEATURE_WLAN_TDLS TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "TDLS Peer Count: %d", pTLCb->ucTdlsPeerCount)); #endif TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "++++++++++++++++++++Registerd Client Information++++++++++")); for ( i =0; iatlSTAClients[i]; if( NULL == pClientSTA || 0 == pClientSTA->ucExists) { continue; } TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "######################STA Index: %d ############################",i)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN_STADescType:")); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "STAId: %d\t STA MAC Address: %pM", pClientSTA->wSTADesc.ucSTAId, pClientSTA->wSTADesc.vSTAMACAddress.bytes)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "STA Type: %d\tProtectedFrame: %d", pClientSTA->wSTADesc.wSTAType, pClientSTA->wSTADesc.ucProtectedFrame)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "QoS: %d\tRxFrameTrans: %d\tTxFrameTrans: %d", pClientSTA->wSTADesc.ucQosEnabled, pClientSTA->wSTADesc.ucSwFrameRXXlation, pClientSTA->wSTADesc.ucSwFrameTXXlation)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "ucUcastSig: %d\tucBcastSig: %d", pClientSTA->wSTADesc.ucUcastSig, pClientSTA->wSTADesc.ucBcastSig)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "ClientIndex: %d\t Exists: %d", i, pClientSTA->ucExists)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TL State: %d\t TL Priority: %d", pClientSTA->tlState, pClientSTA->tlPri)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "ucTxSuspended: %d\tucPktPending: %d", pClientSTA->ucTxSuspended, pClientSTA->ucPktPending)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "ucEAPOLPktPending: %d\tucNoMoreData: %d", pClientSTA->ucEapolPktPending, pClientSTA->ucNoMoreData)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "enableCaching: %d\t fcStaTxDisabled: %d", pClientSTA->enableCaching, pClientSTA->fcStaTxDisabled)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "ucCurrentAC: %d\tucServicedAC: %d", pClientSTA->ucCurrentAC, pClientSTA->ucServicedAC)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TID: %d\tautTxCount[0]: %d\tauRxCount[0]: %d",0, pClientSTA->auTxCount[0], pClientSTA->auRxCount[0])); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "aucAcMask[0]: %d\taucAcMask[1]: %d\taucAcMask[2]: %d\taucAcMask[3]: %d\t", pClientSTA->aucACMask[0], pClientSTA->aucACMask[1], pClientSTA->aucACMask[2], pClientSTA->aucACMask[3])); TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "ucCurrentWeight: %d", pClientSTA->ucCurrentWeight)); if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType) { TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TrafficStatistics for SOFTAP Station:")); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "RUF=%d\tRMF=%d\tRBF=%d", pClientSTA->trafficStatistics.rxUCFcnt, pClientSTA->trafficStatistics.rxMCFcnt, pClientSTA->trafficStatistics.rxBCFcnt)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "RUB=%d\tRMB=%d\tRBB=%d", pClientSTA->trafficStatistics.rxUCBcnt, pClientSTA->trafficStatistics.rxMCBcnt, pClientSTA->trafficStatistics.rxBCBcnt)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TUF=%d\tTMF=%d\tTBF=%d", pClientSTA->trafficStatistics.txUCFcnt, pClientSTA->trafficStatistics.txMCFcnt, pClientSTA->trafficStatistics.txBCFcnt)); TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "TUB=%d\tTMB=%d\tTBB=%d", pClientSTA->trafficStatistics.txUCBcnt, pClientSTA->trafficStatistics.txMCBcnt, pClientSTA->trafficStatistics.txBCBcnt)); } } return; } /*========================================================================== FUNCTION WLANTL_FatalErrorHandler DESCRIPTION Handle Fatal errors detected on the TX path. Currently issues SSR to recover from the error. DEPENDENCIES The TL must be initialized before this gets called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's or WDA's control block can be extracted from its context RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_FatalErrorHandler ( v_PVOID_t *pVosContext ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL: %s Enter ", __func__)); if ( NULL == pVosContext ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Global VoS Context or TL Context are NULL", __func__)); return; } /* * Issue SSR. vos_wlanRestart has tight checks to make sure that * we do not send an FIQ if previous FIQ is not processed */ vos_wlanRestart(VOS_REASON_UNSPECIFIED); } /*========================================================================== FUNCTION WLANTL_TLDebugMessage DESCRIPTION Post a TL Snapshot request, posts message in TxThread. DEPENDENCIES The TL must be initialized before this gets called. PARAMETERS IN displaySnapshot Boolean showing whether to dump the snapshot or not. RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_TLDebugMessage ( v_U32_t debugFlags ) { vos_msg_t vosMsg; VOS_STATUS status; if(debugFlags & WLANTL_DEBUG_TX_SNAPSHOT) { vosMsg.reserved = 0; vosMsg.bodyptr = NULL; vosMsg.type = WLANTL_TX_SNAPSHOT; status = vos_tx_mq_serialize( VOS_MODULE_ID_TL, &vosMsg); if(status != VOS_STATUS_SUCCESS) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "TX Msg Posting Failed with status: %d",status)); return; } } if (debugFlags & WLANTL_DEBUG_FW_CLEANUP) { vosMsg.reserved = 0; vosMsg.bodyptr = NULL; vosMsg.type = WLANTL_TX_FW_DEBUG; status = vos_tx_mq_serialize( VOS_MODULE_ID_TL, &vosMsg); if(status != VOS_STATUS_SUCCESS) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "TX Msg Posting Failed with status: %d",status)); return; } } if(debugFlags & WLANTL_DEBUG_KICKDXE) { vosMsg.reserved = 0; vosMsg.bodyptr = NULL; vosMsg.type = WLANTL_TX_KICKDXE; status = vos_tx_mq_serialize( VOS_MODULE_ID_TL, &vosMsg); if(status != VOS_STATUS_SUCCESS) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "TX Msg Posting Failed with status: %d",status)); return; } } return; } /*========================================================================== FUNCTION WLANTL_FatalError DESCRIPTION Fatal error reported in TX path, post an event to TX Thread for further handling DEPENDENCIES The TL must be initialized before this gets called. PARAMETERS VOID RETURN VALUE None SIDE EFFECTS ============================================================================*/ v_VOID_t WLANTL_FatalError ( v_VOID_t ) { vos_msg_t vosMsg; VOS_STATUS status; vosMsg.reserved = 0; vosMsg.bodyptr = NULL; vosMsg.type = WLANTL_TX_FATAL_ERROR; status = vos_tx_mq_serialize( VOS_MODULE_ID_TL, &vosMsg); if(status != VOS_STATUS_SUCCESS) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: TX Msg Posting Failed with status: %d", __func__,status)); } return; } /*============================================================================ TL STATE MACHINE ============================================================================*/ /*========================================================================== FUNCTION WLANTL_STATxConn DESCRIPTION Transmit in connected state - only EAPOL and WAI packets allowed DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the tx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other return values are possible coming from the called functions. Please check API for additional info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STATxConn ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { v_U16_t usPktLen; VOS_STATUS vosStatus; v_MACADDR_t vDestMacAddr; vos_pkt_t* vosDataBuff = NULL; WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; WLANTL_MetaInfoType tlMetaInfo; v_U8_t ucTypeSubtype = 0; v_U8_t ucTid; v_U8_t extraHeadSpace = 0; v_U8_t ucWDSEnabled = 0; v_U8_t ucAC, ucACMask, i; v_U32_t txFlag = HAL_TX_NO_ENCRYPTION_MASK; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_STATxConn"); *pvosDataBuff = NULL; return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*------------------------------------------------------------------- Disable AC temporary - if successfull retrieve re-enable The order is justified because of the possible scenario - TL tryes to fetch packet for AC and it returns NULL - TL analyzes the data it has received to see if there are any more pkts available for AC -> if not TL will disable AC - however it is possible that while analyzing results TL got preempted by a pending indication where the mask was again set TL will not check again and as a result when it resumes execution it will disable AC To prevent this the AC will be disabled here and if retrieve is successfull it will be re-enabled -------------------------------------------------------------------*/ //LTI:pTLCb->atlSTAClients[ucSTAId]. //LTI: aucACMask[pTLCb->atlSTAClients[ucSTAId].ucCurrentAC] = 0; /*------------------------------------------------------------------------ Fetch packet from HDD ------------------------------------------------------------------------*/ #ifdef FEATURE_WLAN_TDLS if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) && !(vos_concurrent_open_sessions_running()) && !pTLCb->ucTdlsPeerCount) { #else if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) && !(vos_concurrent_open_sessions_running())) { #endif ucAC = pClientSTA->ucCurrentAC; /*------------------------------------------------------------------- Disable AC temporary - if successfull retrieve re-enable The order is justified because of the possible scenario - TL tryes to fetch packet for AC and it returns NULL - TL analyzes the data it has received to see if there are any more pkts available for AC -> if not TL will disable AC - however it is possible that while analyzing results TL got preempted by a pending indication where the mask was again set TL will not check again and as a result when it resumes execution it will disable AC To prevent this the AC will be disabled here and if retrieve is successfull it will be re-enabled -------------------------------------------------------------------*/ pClientSTA->aucACMask[ucAC] = 0; } else { //softap case ucAC = pTLCb->uCurServedAC; pClientSTA->aucACMask[ucAC] = 0; } /*You make an initial assumption that HDD has no more data and if the assumption was wrong you reset the flags to their original state This will prevent from exposing a race condition between checking with HDD for packets and setting the flags to false*/ //LTI: vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 0); //LTI: pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1; vos_atomic_set_U8( &pClientSTA->ucPktPending, 0); WLAN_TL_AC_ARRAY_2_MASK( pClientSTA, ucACMask, i); /*You make an initial assumption that HDD has no more data and if the assumption was wrong you reset the flags to their original state This will prevent from exposing a race condition between checking with HDD for packets and setting the flags to false*/ if ( 0 == ucACMask ) { pClientSTA->ucNoMoreData = 1; } else { vos_atomic_set_U8( &pClientSTA->ucPktPending, 1); } VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: WLANTL_STATxConn fetching packet from HDD for AC: %d AC Mask: %d Pkt Pending: %d", ucAC, ucACMask, pClientSTA->ucPktPending); /*------------------------------------------------------------------------ Fetch tx packet from HDD ------------------------------------------------------------------------*/ vosStatus = pClientSTA->pfnSTAFetchPkt( pvosGCtx, &ucSTAId, ucAC, &vosDataBuff, &tlMetaInfo ); if (( VOS_STATUS_SUCCESS != vosStatus ) || ( NULL == vosDataBuff )) { TLLOG1(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:No more data at HDD status %d", vosStatus)); *pvosDataBuff = NULL; /*-------------------------------------------------------------------- Reset AC for the serviced station to the highest priority AC -> due to no more data at the station Even if this AC is not supported by the station, correction will be made in the main TL loop --------------------------------------------------------------------*/ pClientSTA->ucCurrentAC = WLANTL_AC_HIGH_PRIO; pClientSTA->ucCurrentWeight = 0; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: WLANTL_STATxConn no more packets in HDD for AC: %d AC Mask: %d", ucAC, ucACMask); return vosStatus; } /*There are still packets in HDD - set back the pending packets and the no more data assumption*/ vos_atomic_set_U8( &pClientSTA->ucPktPending, 1); pClientSTA->ucNoMoreData = 0; pClientSTA->aucACMask[ucAC] = 1; #ifdef WLAN_PERF vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_BAL, (v_PVOID_t)0); #endif /*WLAN_PERF*/ #ifdef FEATURE_WLAN_WAPI /*------------------------------------------------------------------------ If the packet is neither an Eapol packet nor a WAI packet then drop it ------------------------------------------------------------------------*/ if ( 0 == tlMetaInfo.ucIsEapol && 0 == tlMetaInfo.ucIsWai ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:Only EAPOL or WAI packets allowed before authentication")); /* Fail tx for packet */ pClientSTA->pfnSTATxComp( pvosGCtx, vosDataBuff, VOS_STATUS_E_BADMSG); vosDataBuff = NULL; *pvosDataBuff = NULL; return VOS_STATUS_SUCCESS; } #else if ( 0 == tlMetaInfo.ucIsEapol ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Received non EAPOL packet before authentication")); /* Fail tx for packet */ pClientSTA->pfnSTATxComp( pvosGCtx, vosDataBuff, VOS_STATUS_E_BADMSG); vosDataBuff = NULL; *pvosDataBuff = NULL; return VOS_STATUS_SUCCESS; } #endif /* FEATURE_WLAN_WAPI */ /*------------------------------------------------------------------------- Check TID -------------------------------------------------------------------------*/ ucTid = tlMetaInfo.ucTID; /*Make sure TID is valid*/ if ( WLANTL_TID_INVALID(ucTid)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Invalid TID sent in meta info %d - defaulting to 0 (BE)", ucTid)); ucTid = 0; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Attaching BD header to pkt on WLANTL_STATxConn")); #ifdef FEATURE_WLAN_WAPI /*------------------------------------------------------------------------ Translate 802.3 frame to 802.11 if Frame translation is enabled or if frame is a WAI frame. ------------------------------------------------------------------------*/ if ( ( 1 == tlMetaInfo.ucIsWai ) || ( 0 == tlMetaInfo.ucDisableFrmXtl ) ) #else /*------------------------------------------------------------------------ Translate 802.3 frame to 802.11 if Frame translation is enabled ------------------------------------------------------------------------*/ if ( ( 0 == tlMetaInfo.ucDisableFrmXtl ) && ( 0 != pClientSTA->wSTADesc.ucSwFrameTXXlation) ) #endif //#ifdef FEATURE_WLAN_WAPI { vosStatus = WLANTL_Translate8023To80211Header( vosDataBuff, &vosStatus, pTLCb, &ucSTAId, &tlMetaInfo, &ucWDSEnabled, &extraHeadSpace); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Error when translating header WLANTL_STATxConn")); return vosStatus; } tlMetaInfo.ucDisableFrmXtl = 1; } /*------------------------------------------------------------------------- Call HAL to fill BD header -------------------------------------------------------------------------*/ ucTypeSubtype |= (WLANTL_80211_DATA_TYPE << 4); if ( pClientSTA->wSTADesc.ucQosEnabled ) { ucTypeSubtype |= (WLANTL_80211_DATA_QOS_SUBTYPE); } #ifdef FEATURE_WLAN_WAPI /* TL State does not transition to AUTHENTICATED till GTK is installed, So in * case of WPA where GTK handshake is done after the 4 way handshake, the * unicast 2/2 EAPOL packet from the STA->AP has to be encrypted even before * the TL is in authenticated state. Since the PTK has been installed * already (after the 4 way handshake) we make sure that all traffic * is encrypted henceforth.(Note: TL is still not in AUTHENTICATED state so * we will only allow EAPOL data or WAI in case of WAPI) */ if (tlMetaInfo.ucIsEapol && pClientSTA->ptkInstalled) { txFlag = 0; } #else if (pClientSTA->ptkInstalled) { txFlag = 0; } #endif vosStatus = (VOS_STATUS)WDA_DS_BuildTxPacketInfo( pvosGCtx, vosDataBuff , &vDestMacAddr, tlMetaInfo.ucDisableFrmXtl, &usPktLen, pClientSTA->wSTADesc.ucQosEnabled, ucWDSEnabled, extraHeadSpace, ucTypeSubtype, &pClientSTA->wSTADesc.vSelfMACAddress, ucTid, txFlag, tlMetaInfo.usTimeStamp, tlMetaInfo.ucIsEapol || tlMetaInfo.ucIsWai, tlMetaInfo.ucIsArp, tlMetaInfo.ucUP, tlMetaInfo.ucTxBdToken); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while attempting to fill BD %d", vosStatus)); *pvosDataBuff = NULL; return vosStatus; } /*----------------------------------------------------------------------- Update tx counter for BA session query for tx side !1 - should this be done for EAPOL frames? -----------------------------------------------------------------------*/ pClientSTA->auTxCount[ucTid]++; vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)pClientSTA->pfnSTATxComp ); /*------------------------------------------------------------------------ Save data to input pointer for TL core ------------------------------------------------------------------------*/ *pvosDataBuff = vosDataBuff; /*security frames cannot be delayed*/ pTLCb->bUrgent = TRUE; /* TX Statistics */ if (!(tlMetaInfo.ucBcast || tlMetaInfo.ucMcast)) { /* This is TX UC frame */ pClientSTA->trafficStatistics.txUCFcnt++; pClientSTA->trafficStatistics.txUCBcnt += usPktLen; } return VOS_STATUS_SUCCESS; }/* WLANTL_STATxConn */ /*========================================================================== FUNCTION WLANTL_STATxAuth DESCRIPTION Transmit in authenticated state - all data allowed DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the tx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other return values are possible coming from the called functions. Please check API for additional info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STATxAuth ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { v_U16_t usPktLen; VOS_STATUS vosStatus; v_MACADDR_t vDestMacAddr; vos_pkt_t* vosDataBuff = NULL; WLANTL_CbType* pTLCb = NULL; WLANTL_MetaInfoType tlMetaInfo; v_U8_t ucTypeSubtype = 0; WLANTL_ACEnumType ucAC; WLANTL_ACEnumType ucNextAC; v_U8_t ucTid; v_U8_t ucSwFrmXtl = 0; v_U8_t extraHeadSpace = 0; WLANTL_STAClientType *pStaClient = NULL; v_U8_t ucWDSEnabled = 0; v_U32_t ucTxFlag = 0; v_U8_t ucACMask, i; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (( NULL == pTLCb ) || ( NULL == pvosDataBuff )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid input params on WLANTL_STATxAuth TL %pK DB %pK", pTLCb, pvosDataBuff)); if (NULL != pvosDataBuff) { *pvosDataBuff = NULL; } if(NULL != pTLCb) { if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } pTLCb->atlSTAClients[ucSTAId]->ucNoMoreData = 1; } return VOS_STATUS_E_FAULT; } pStaClient = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pStaClient ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } vos_mem_zero(&tlMetaInfo, sizeof(tlMetaInfo)); /*------------------------------------------------------------------------ Fetch packet from HDD ------------------------------------------------------------------------*/ #ifdef FEATURE_WLAN_TDLS if ((WLAN_STA_SOFTAP != pStaClient->wSTADesc.wSTAType) && (!vos_concurrent_open_sessions_running()) && !pTLCb->ucTdlsPeerCount) { #else if ((WLAN_STA_SOFTAP != pStaClient->wSTADesc.wSTAType) && (!vos_concurrent_open_sessions_running())) { #endif ucAC = pStaClient->ucCurrentAC; /*------------------------------------------------------------------- Disable AC temporary - if successfull retrieve re-enable The order is justified because of the possible scenario - TL tryes to fetch packet for AC and it returns NULL - TL analyzes the data it has received to see if there are any more pkts available for AC -> if not TL will disable AC - however it is possible that while analyzing results TL got preempted by a pending indication where the mask was again set TL will not check again and as a result when it resumes execution it will disable AC To prevent this the AC will be disabled here and if retrieve is successfull it will be re-enabled -------------------------------------------------------------------*/ pStaClient->aucACMask[pStaClient->ucCurrentAC] = 0; // don't reset it, as other AC queues in HDD may have packets //vos_atomic_set_U8( &pStaClient->ucPktPending, 0); } else { //softap case ucAC = pTLCb->uCurServedAC; pStaClient->aucACMask[ucAC] = 0; //vos_atomic_set_U8( &pStaClient->ucPktPending, 0); } WLAN_TL_AC_ARRAY_2_MASK( pStaClient, ucACMask, i); /*You make an initial assumption that HDD has no more data and if the assumption was wrong you reset the flags to their original state This will prevent from exposing a race condition between checking with HDD for packets and setting the flags to false*/ if ( 0 == ucACMask ) { vos_atomic_set_U8( &pStaClient->ucPktPending, 0); pStaClient->ucNoMoreData = 1; } vosStatus = pStaClient->pfnSTAFetchPkt( pvosGCtx, &ucSTAId, ucAC, &vosDataBuff, &tlMetaInfo ); if (( VOS_STATUS_SUCCESS != vosStatus ) || ( NULL == vosDataBuff )) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:Failed while attempting to fetch pkt from HDD QId:%d status:%d", ucAC, vosStatus); *pvosDataBuff = NULL; /*-------------------------------------------------------------------- Reset AC for the serviced station to the highest priority AC -> due to no more data at the station Even if this AC is not supported by the station, correction will be made in the main TL loop --------------------------------------------------------------------*/ pStaClient->ucCurrentAC = WLANTL_AC_HIGH_PRIO; pStaClient->ucCurrentWeight = 0; return vosStatus; } WLANTL_StatHandleTXFrame(pvosGCtx, ucSTAId, vosDataBuff, NULL, &tlMetaInfo); /*There are still packets in HDD - set back the pending packets and the no more data assumption*/ vos_atomic_set_U8( &pStaClient->ucPktPending, 1); pStaClient->ucNoMoreData = 0; if (WLAN_STA_SOFTAP != pStaClient->wSTADesc.wSTAType) { // don't need to set it, as we don't reset it in this function. //vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 1); } #ifdef WLAN_PERF vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_BAL, (v_PVOID_t)0); #endif /*WLAN_PERF*/ /*------------------------------------------------------------------------- Check TID -------------------------------------------------------------------------*/ ucTid = tlMetaInfo.ucTID; /*Make sure TID is valid*/ if ( WLANTL_TID_INVALID(ucTid)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Invalid TID sent in meta info %d - defaulting to 0 (BE)", ucTid)); ucTid = 0; } /*Save for UAPSD timer consideration*/ pStaClient->ucServicedAC = ucAC; if ( ucAC == pStaClient->ucCurrentAC ) { pStaClient->aucACMask[pStaClient->ucCurrentAC] = 1; pStaClient->ucCurrentWeight--; } else { pStaClient->ucCurrentAC = ucAC; pStaClient->ucCurrentWeight = pTLCb->tlConfigInfo.ucAcWeights[ucAC] - 1; pStaClient->aucACMask[pStaClient->ucCurrentAC] = 1; } if (WLAN_STA_SOFTAP != pStaClient->wSTADesc.wSTAType) { if ( 0 == pStaClient->ucCurrentWeight ) { WLANTL_ACEnumType tempAC = ucAC; /*----------------------------------------------------------------------- Choose next AC - !!! optimize me -----------------------------------------------------------------------*/ while ( 0 != ucACMask ) { if(tempAC == WLANTL_AC_BK) ucNextAC = WLANTL_AC_HIGH_PRIO; else ucNextAC = (tempAC - 1); if ( 0 != pStaClient->aucACMask[ucNextAC] ) { pStaClient->ucCurrentAC = ucNextAC; pStaClient->ucCurrentWeight = pTLCb->tlConfigInfo.ucAcWeights[ucNextAC]; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Changing serviced AC to: %d with Weight: %d", pStaClient->ucCurrentAC , pStaClient->ucCurrentWeight)); break; } tempAC = ucNextAC; } } } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Attaching BD header to pkt on WLANTL_STATxAuth")); /*------------------------------------------------------------------------ Translate 802.3 frame to 802.11 ------------------------------------------------------------------------*/ if ( 0 == tlMetaInfo.ucDisableFrmXtl ) { /* Needs frame translation */ // if the client has not enabled SW-only frame translation // and if the frame is a unicast frame // (HW frame translation does not support multiple broadcast domains // so we use SW frame translation for broadcast/multicast frames) #ifdef FEATURE_WLAN_WAPI // and if the frame is not a WAPI frame #endif // then use HW_based frame translation if ( ( 0 == pStaClient->wSTADesc.ucSwFrameTXXlation ) && ( 0 == tlMetaInfo.ucBcast ) && ( 0 == tlMetaInfo.ucMcast ) #ifdef FEATURE_WLAN_WAPI && ( tlMetaInfo.ucIsWai != 1 ) #endif ) { #ifdef WLAN_PERF v_U32_t uFastFwdOK = 0; /* HW based translation. See if the frame could be fast forwarded */ WDA_TLI_FastHwFwdDataFrame( pvosGCtx, vosDataBuff , &vosStatus, &uFastFwdOK, &tlMetaInfo, &pStaClient->wSTADesc); if( VOS_STATUS_SUCCESS == vosStatus ) { if(uFastFwdOK) { /* Packet could be fast forwarded now */ vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)pStaClient->pfnSTATxComp ); *pvosDataBuff = vosDataBuff; /* TODO: Do we really need to update WLANTL_HSHandleTXFrame() stats for every pkt? */ pStaClient->auTxCount[tlMetaInfo.ucTID]++; return vosStatus; } /* can't be fast forwarded, fall through normal (slow) path. */ } else { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while attempting to fastFwd BD %d", vosStatus)); *pvosDataBuff = NULL; return vosStatus; } #endif /*WLAN_PERF*/ } else { /* SW based translation */ vosStatus = WLANTL_Translate8023To80211Header( vosDataBuff, &vosStatus, pTLCb, &ucSTAId, &tlMetaInfo, &ucWDSEnabled, &extraHeadSpace); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Error when translating header WLANTL_STATxAuth")); return vosStatus; } TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL software translation success")); ucSwFrmXtl = 1; tlMetaInfo.ucDisableFrmXtl = 1; } } #ifdef FEATURE_WLAN_TDLS /*In case of TDLS, if the packet is destined to TDLS STA ucSTAId may change. so update the pStaClient accordingly */ pStaClient = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pStaClient ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "pStaClient is NULL %s", __func__)); return VOS_STATUS_E_FAILURE; } #endif /*------------------------------------------------------------------------- Call HAL to fill BD header -------------------------------------------------------------------------*/ ucTypeSubtype |= (WLANTL_80211_DATA_TYPE << 4); if ( pStaClient->wSTADesc.ucQosEnabled ) { ucTypeSubtype |= (WLANTL_80211_DATA_QOS_SUBTYPE); } /* ucAC now points to TL Q ID with a new queue added in TL, * hence look for the uapsd info for the correct AC that * this packet belongs to. */ ucTxFlag = (0 != pStaClient->wUAPSDInfo[tlMetaInfo.ac].ucSet)? HAL_TRIGGER_ENABLED_AC_MASK:0; #ifdef FEATURE_WLAN_WAPI if ( pStaClient->wSTADesc.ucIsWapiSta == 1 ) { #ifdef LIBRA_WAPI_SUPPORT ucTxFlag = ucTxFlag | HAL_WAPI_STA_MASK; #endif //LIBRA_WAPI_SUPPORT if ( tlMetaInfo.ucIsWai == 1 ) { ucTxFlag = ucTxFlag | HAL_TX_NO_ENCRYPTION_MASK; } } #endif /* FEATURE_WLAN_WAPI */ #ifdef FEATURE_WLAN_TDLS if ( pStaClient->wSTADesc.wSTAType == WLAN_STA_TDLS ) { ucTxFlag = ucTxFlag | HAL_TDLS_PEER_STA_MASK; } #endif /* FEATURE_WLAN_TDLS */ if( tlMetaInfo.ucIsArp ) { if (pTLCb->track_arp) { if (vos_check_arp_target_ip(vosDataBuff)) { ucTxFlag |= HAL_USE_FW_IN_TX_PATH; ucTxFlag |= HAL_TXCOMP_REQUESTED_MASK; tlMetaInfo.ucTxBdToken = ++ pTLCb->txbd_token; } } if (pStaClient->arpOnWQ5) { ucTxFlag |= HAL_USE_FW_IN_TX_PATH; } if (pStaClient->arpRate == 0) { ucTxFlag |= HAL_USE_BD_RATE_1_MASK; } else if (pStaClient->arpRate == 1 || pStaClient->arpRate == 3) { pStaClient->arpRate ^= 0x2; ucTxFlag |= HAL_USE_BD_RATE_1_MASK<<(pStaClient->arpRate-1); } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "arp pkt sending on BD rate: %hhu", pStaClient->arpRate)); } vosStatus = (VOS_STATUS)WDA_DS_BuildTxPacketInfo( pvosGCtx, vosDataBuff , &vDestMacAddr, tlMetaInfo.ucDisableFrmXtl, &usPktLen, pStaClient->wSTADesc.ucQosEnabled, ucWDSEnabled, extraHeadSpace, ucTypeSubtype, &pStaClient->wSTADesc.vSelfMACAddress, ucTid, ucTxFlag, tlMetaInfo.usTimeStamp, tlMetaInfo.ucIsEapol, tlMetaInfo.ucIsArp, tlMetaInfo.ucUP, tlMetaInfo.ucTxBdToken); if(!VOS_IS_STATUS_SUCCESS(vosStatus)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Fill TX BD Error status %d", vosStatus)); return vosStatus; } /* TX Statistics */ if (!(tlMetaInfo.ucBcast || tlMetaInfo.ucMcast)) { /* This is TX UC frame */ pStaClient->trafficStatistics.txUCFcnt++; pStaClient->trafficStatistics.txUCBcnt += usPktLen; } #ifndef FEATURE_WLAN_TDLS /*----------------------------------------------------------------------- Update tx counter for BA session query for tx side -----------------------------------------------------------------------*/ pStaClient->auTxCount[ucTid]++; #else pTLCb->atlSTAClients[ucSTAId]->auTxCount[ucTid]++; #endif /* This code is to send traffic with lower priority AC when we does not get admitted to send it. Today HAL does not downgrade AC so this code does not get executed.(In other words, HAL doesn’t change tid. The if statement is always false.) NOTE: In the case of LA downgrade occurs in HDD (that was the change Phani made during WMM-AC plugfest). If WM & BMP also took this approach, then there will be no need for any AC downgrade logic in TL/WDI. */ #if 0 if (( ucTid != tlMetaInfo.ucTID ) && ( 0 != pStaClient->wSTADesc.ucQosEnabled ) && ( 0 != ucSwFrmXtl )) { /*--------------------------------------------------------------------- !! FIX me: Once downgrading is clear put in the proper change ---------------------------------------------------------------------*/ ucQCOffset = WLANHAL_TX_BD_HEADER_SIZE + WLANTL_802_11_HEADER_LEN; //!!!Fix this replace peek with extract vos_pkt_peek_data( vosDataBuff, ucQCOffset,(v_PVOID_t)&pucQosCtrl, sizeof(*pucQosCtrl)); *pucQosCtrl = ucTid; //? proper byte order } #endif if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while attempting to fill BD %d", vosStatus)); *pvosDataBuff = NULL; return vosStatus; } vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)pStaClient->pfnSTATxComp ); *pvosDataBuff = vosDataBuff; /*BE & BK can be delayed, VO and VI not frames cannot be delayed*/ if ( pStaClient->ucServicedAC > WLANTL_AC_BE ) { pTLCb->bUrgent= TRUE; } return VOS_STATUS_SUCCESS; }/* WLANTL_STATxAuth */ /*========================================================================== FUNCTION WLANTL_STATxDisc DESCRIPTION Transmit in disconnected state - no data allowed DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the tx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STATxDisc ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_STATxAuth")); *pvosDataBuff = NULL; return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*------------------------------------------------------------------------ Error ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Packet should not be transmitted in state disconnected ignoring" " request")); *pvosDataBuff = NULL; pClientSTA->ucNoMoreData = 1; //Should not be anything pending in disconnect state vos_atomic_set_U8( &pClientSTA->ucPktPending, 0); return VOS_STATUS_SUCCESS; }/* WLANTL_STATxDisc */ /*========================================================================== FUNCTION WLANTL_STARxConn DESCRIPTION Receive in connected state - only EAPOL DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the tx/rx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STARxConn ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; v_U16_t usEtherType = 0; v_U16_t usPktLen; v_U8_t ucMPDUHOffset; v_U16_t usMPDUDOffset; v_U16_t usMPDULen; v_U8_t ucMPDUHLen; v_U16_t usActualHLen = 0; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; vos_pkt_t* vosDataBuff; v_PVOID_t aucBDHeader; v_U8_t ucTid; WLANTL_RxMetaInfoType wRxMetaInfo; v_U8_t ucAsf; /* AMSDU sub frame */ /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if (( NULL == pvosDataBuff ) || ( NULL == ( vosDataBuff = *pvosDataBuff ))) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_STARxConn")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*------------------------------------------------------------------------ Extract BD header and check if valid ------------------------------------------------------------------------*/ vosStatus = WDA_DS_PeekRxPacketInfo( vosDataBuff, (v_PVOID_t)&aucBDHeader, 0/*Swap BD*/ ); if ( NULL == aucBDHeader ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Cannot extract BD header")); VOS_ASSERT( 0 ); return VOS_STATUS_E_FAULT; } ucMPDUHOffset = (v_U8_t)WDA_GET_RX_MPDU_HEADER_OFFSET(aucBDHeader); usMPDUDOffset = (v_U16_t)WDA_GET_RX_MPDU_DATA_OFFSET(aucBDHeader); usMPDULen = (v_U16_t)WDA_GET_RX_MPDU_LEN(aucBDHeader); ucMPDUHLen = (v_U8_t)WDA_GET_RX_MPDU_HEADER_LEN(aucBDHeader); ucTid = (v_U8_t)WDA_GET_RX_TID(aucBDHeader); ucAsf = (v_U8_t)WDA_GET_RX_ASF(aucBDHeader); vos_pkt_get_packet_length( vosDataBuff, &usPktLen); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:BD header processing data: HO %d DO %d Len %d HLen %d", ucMPDUHOffset, usMPDUDOffset, usMPDULen, ucMPDUHLen)); /*It will cut out the 802.11 header if not used*/ if ( VOS_STATUS_SUCCESS != WDA_DS_TrimRxPacketInfo( vosDataBuff ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:BD header corrupted - dropping packet")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } if (ucAsf) { vos_pkt_return_packet(vosDataBuff); *pvosDataBuff = NULL; VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: AMSDU frames are not allowed while authentication - dropping"); return VOS_STATUS_SUCCESS; } vosStatus = WLANTL_GetEtherType(aucBDHeader,vosDataBuff,ucMPDUHLen,&usEtherType); if( VOS_IS_STATUS_SUCCESS(vosStatus) ) { #ifdef FEATURE_WLAN_WAPI /* If frame is neither an EAPOL frame nor a WAI frame then we drop the frame*/ /* TODO: Do we need a check to see if we are in WAPI mode? If not is it possible */ /* that we get an EAPOL packet in WAPI mode or vice versa? */ if ( WLANTL_LLC_8021X_TYPE != usEtherType && WLANTL_LLC_WAI_TYPE != usEtherType ) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:RX Frame not EAPOL or WAI EtherType %d - dropping", usEtherType ); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); } #else if ( WLANTL_LLC_8021X_TYPE != usEtherType ) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:RX Frame not EAPOL EtherType %d - dropping", usEtherType); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); } #endif /* FEATURE_WLAN_WAPI */ else /* Frame is an EAPOL frame or a WAI frame*/ { MTRACE(vos_trace(VOS_MODULE_ID_TL, TRACE_CODE_TL_RX_CONN_EAPOL, ucSTAId, usEtherType )); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL:RX Frame EAPOL EtherType %d - processing", usEtherType); if (( 0 == WDA_GET_RX_FT_DONE(aucBDHeader) ) && ( 0 != pClientSTA->wSTADesc.ucSwFrameRXXlation)) { if (usMPDUDOffset > ucMPDUHOffset) { usActualHLen = usMPDUDOffset - ucMPDUHOffset; } vosStatus = WLANTL_Translate80211To8023Header( vosDataBuff, &vosStatus, usActualHLen, ucMPDUHLen, pTLCb, ucSTAId, bForwardIAPPwithLLC); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Failed to translate from 802.11 to 802.3 - dropping")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return vosStatus; } } /*------------------------------------------------------------------- Increment receive counter -------------------------------------------------------------------*/ if ( !WLANTL_TID_INVALID( ucTid) ) { pClientSTA->auRxCount[ucTid]++; } else { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid tid %d (Station ID %d) on %s", ucTid, ucSTAId, __func__)); vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_E_FAILURE; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Sending EAPoL frame to station %d AC %d", ucSTAId, ucTid)); /*------------------------------------------------------------------- !!!Assuming TID = UP mapping -------------------------------------------------------------------*/ wRxMetaInfo.ucUP = ucTid; TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL %s:Sending data chain to station", __func__)); if ( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType ) { wRxMetaInfo.ucDesSTAId = WLAN_RX_SAP_SELF_STA_ID; pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId, &wRxMetaInfo ); } else pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId, &wRxMetaInfo ); }/*EAPOL frame or WAI frame*/ }/*vos status success*/ return VOS_STATUS_SUCCESS; }/* WLANTL_STARxConn */ /*========================================================================== FUNCTION WLANTL_FwdPktToHDD DESCRIPTION Determine the Destation Station ID and route the Frame to Upper Layer DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the rx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_FwdPktToHDD ( v_PVOID_t pvosGCtx, vos_pkt_t* pvosDataBuff, v_U8_t ucSTAId ) { v_MACADDR_t DestMacAddress; v_MACADDR_t *pDestMacAddress = &DestMacAddress; v_SIZE_t usMacAddSize = VOS_MAC_ADDR_SIZE; WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; vos_pkt_t* vosDataBuff ; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_U32_t* STAMetaInfoPtr; vos_pkt_t* vosNextDataBuff ; v_U8_t ucDesSTAId; WLANTL_RxMetaInfoType wRxMetaInfo; /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if (( NULL == pvosDataBuff ) || ( NULL == ( vosDataBuff = pvosDataBuff ))) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_FwdPktToHdd")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_FwdPktToHdd")); return VOS_STATUS_E_FAULT; } if(WLANTL_STA_ID_INVALID(ucSTAId)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"ucSTAId %d is not valid", ucSTAId)); return VOS_STATUS_E_INVAL; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /* This the change required for SoftAp to handle Reordered Buffer. Since a STA may have packets destined to multiple destinations we have to process each packet at a time and determine its Destination. So the Voschain provided by Reorder code is unchain and forwarded to Upper Layer after Determining the Destination */ vosDataBuff = pvosDataBuff; while (vosDataBuff != NULL) { vos_pkt_walk_packet_chain( vosDataBuff, &vosNextDataBuff, 1/*true*/ ); vos_pkt_get_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t *)&STAMetaInfoPtr ); wRxMetaInfo.ucUP = (v_U8_t)((uintptr_t)STAMetaInfoPtr & WLANTL_AC_MASK); ucDesSTAId = (v_U8_t)(((uintptr_t)STAMetaInfoPtr) >> WLANTL_STAID_OFFSET); vosStatus = vos_pkt_extract_data( vosDataBuff, 0, (v_VOID_t *)pDestMacAddress, &usMacAddSize); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: recv corrupted data packet")); vos_pkt_return_packet(vosDataBuff); return vosStatus; } TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "station mac "MAC_ADDRESS_STR, MAC_ADDR_ARRAY(pDestMacAddress->bytes))); if (vos_is_macaddr_broadcast( pDestMacAddress ) || vos_is_macaddr_group(pDestMacAddress)) { // destination is mc/bc station ucDesSTAId = WLAN_RX_BCMC_STA_ID; TLLOG4(VOS_TRACE( VOS_MODULE_ID_HDD_SOFTAP, VOS_TRACE_LEVEL_INFO_LOW, "%s: BC/MC packet, id %d", __func__, WLAN_RX_BCMC_STA_ID)); } else { if (vos_is_macaddr_equal(pDestMacAddress, &pClientSTA->wSTADesc.vSelfMACAddress)) { // destination is AP itself ucDesSTAId = WLAN_RX_SAP_SELF_STA_ID; TLLOG4(VOS_TRACE( VOS_MODULE_ID_HDD_SOFTAP, VOS_TRACE_LEVEL_INFO_LOW, "%s: packet to AP itself, id %d", __func__, WLAN_RX_SAP_SELF_STA_ID)); } else if (( WLAN_MAX_STA_COUNT <= ucDesSTAId ) || (NULL != pTLCb->atlSTAClients[ucDesSTAId] && pTLCb->atlSTAClients[ucDesSTAId]->ucExists == 0)) { // destination station is something else TLLOG4(VOS_TRACE( VOS_MODULE_ID_HDD_SOFTAP, VOS_TRACE_LEVEL_INFO_LOW, "%s: get an station index larger than WLAN_MAX_STA_COUNT %d", __func__, ucDesSTAId)); ucDesSTAId = WLAN_RX_SAP_SELF_STA_ID; } //loopback unicast station comes here } wRxMetaInfo.ucUP = (v_U8_t)((uintptr_t)STAMetaInfoPtr & WLANTL_AC_MASK); wRxMetaInfo.ucDesSTAId = ucDesSTAId; vosStatus = pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucDesSTAId, &wRxMetaInfo ); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: failed to send pkt to HDD")); vos_pkt_return_packet(vosDataBuff); return vosStatus; } vosDataBuff = vosNextDataBuff; } return VOS_STATUS_SUCCESS; } #ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD void WLANTL_StopRxRateMonitor(v_PVOID_t pvosGCtx) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pvosGCtx); if (!pTLCb) return; pTLCb->gDsRxRoamStats.running = eWLAN_PAL_FALSE; } void WLANTL_StartRxRateMonitor(v_PVOID_t pvosGCtx, v_U8_t staId, v_U16_t minRate, v_U16_t maxRate, v_U8_t minPercentage, v_U16_t minPktRequired, void *hHal, v_U64_t timeToWait, void (*triggerRoamScanfn) (void *, v_U8_t)) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pvosGCtx); if (!pTLCb) return; pTLCb->gDsRxRoamStats.running = eWLAN_PAL_TRUE; pTLCb->gDsRxRoamStats.index = 0; pTLCb->gDsRxRoamStats.lastTriggerTime = jiffies_to_msecs(jiffies); pTLCb->gDsRxRoamStats.maxRate = maxRate; pTLCb->gDsRxRoamStats.minRate = minRate; pTLCb->gDsRxRoamStats.staId = staId; pTLCb->gDsRxRoamStats.minPercentage = minPercentage; pTLCb->gDsRxRoamStats.timeToWait = timeToWait * 1000; pTLCb->gDsRxRoamStats.intialPktToStart = 0; pTLCb->gDsRxRoamStats.minPktRequired = minPktRequired; pTLCb->gDsRxRoamStats.triggerRoamScanfn = triggerRoamScanfn; pTLCb->gDsRxRoamStats.hHal = hHal; vos_mem_zero(pTLCb->gDsRxRoamStats.rxRoamStats, ROAM_MAX_INDEX_NUM * sizeof(WLANTL_RoamTrafficStatsType)); VOS_TRACE(VOS_MODULE_ID_WDI, VOS_TRACE_LEVEL_DEBUG, "staId=%d, minRate=%d maxRate=%d minPercentage=%d minPktRequired=%d", staId, minRate, maxRate, minPercentage, minPktRequired); } void static WLANTL_ClearAllRoamStats(WLANTL_CbType *pTLCb) { pTLCb->gDsRxRoamStats.index = 0; pTLCb->gDsRxRoamStats.totalPkt = 0; pTLCb->gDsRxRoamStats.lowRatePkt = 0; pTLCb->gDsRxRoamStats.intialPktToStart = 0; vos_mem_zero(pTLCb->gDsRxRoamStats.rxRoamStats, ROAM_MAX_INDEX_NUM * sizeof(WLANTL_RoamTrafficStatsType)); } /* * WLANTL_ClearRoamStatsTillIndex : This API will clear older data * at the indexes. * * Since its a circular buffer we don't know if we are filling * data first time or some older data was already present at * the index. In that case we should clear the older data from * current index to new index and subtract this data from * global count as well before filling new one. */ static inline void WLANTL_ClearRoamStatsTillIndex(WLANTL_CbType *pTLCb, v_U8_t newIndex) { while (pTLCb->gDsRxRoamStats.index < newIndex) { pTLCb->gDsRxRoamStats.index++; pTLCb->gDsRxRoamStats.totalPkt -= pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index].totalPktRcvd; pTLCb->gDsRxRoamStats.lowRatePkt -= pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index].lowRateRxPacketsRcvd; pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index].totalPktRcvd = 0; pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index].lowRateRxPacketsRcvd = 0; } } static void WLANTL_ClearOldPERStats(WLANTL_CbType *pTLCb, v_U8_t incrementCnt) { v_U8_t newIndex; newIndex = (pTLCb->gDsRxRoamStats.index + incrementCnt) % ROAM_MAX_INDEX_NUM; /* We have crossed the max limit of buffer, clear the stats * till ROAM_MAX_INDEX_NUM and set index as 0 */ if ((pTLCb->gDsRxRoamStats.index + incrementCnt) >= ROAM_MAX_INDEX_NUM) { WLANTL_ClearRoamStatsTillIndex(pTLCb, ROAM_MAX_INDEX_NUM - 1); pTLCb->gDsRxRoamStats.index = -1; } /* Clear the stats from current index till new index */ WLANTL_ClearRoamStatsTillIndex(pTLCb, newIndex); } /* * This API implements a circular buffer to store rate stats for a station to * trigger PER based roam scan. * API will start monitoring only if DUT gets continues packets which are below * configured rate. In the upper rates, this should have minimal effect on data * throughput. * * This API will store stats in a circular buffer of size ROAM_MAX_INDEX_NUM * where each index will have time duration of ROAM_PER_INDEX_TIME. * Using a buffer instead of counter will help to maintain stats of time * duration ROAM_PER_INDEX_TIME * ROAM_MAX_INDEX_NUM. Whenever host gets a new * packet, it will remove last ROAM_PER_INDEX_TIME duration of packets from * global entry and index entry and fill new data. * * Global stats of data also be maintained so that host need not to parse whole * buffer while checking the trigger condition * Each of the index will be having the packets stats at duration of * ROAM_PER_INDEX_TIME from the first packet which arrived in that. * Global index will be used to calculate new index position to fill once host * gets a packet. */ static void WLANTL_updatePERStats(WLANTL_CbType *pTLCb, v_U8_t rateIndex) { v_U8_t incrementCnt = 0; v_U64_t currentTime, timeDifference; /* * Host will start monitoring Rx rates only if it gets * MIN_PKTS_TO_START_MONTIOR number of pkts continuously below min rate * This will make sure we never do this much processing in high * rates/throughput cases */ if(pTLCb->gDsRxRoamStats.intialPktToStart < MIN_PKTS_TO_START_MONTIOR) { if (gTLRateInfo[rateIndex].phyRate < pTLCb->gDsRxRoamStats.minRate) pTLCb->gDsRxRoamStats.intialPktToStart++; else pTLCb->gDsRxRoamStats.intialPktToStart = 0; return; } currentTime = jiffies_to_msecs(jiffies); /* * scan was triggered in last timeToWait time duration * Wait for timeToWait before monitoring again. */ if((currentTime - pTLCb->gDsRxRoamStats.lastTriggerTime) < pTLCb->gDsRxRoamStats.timeToWait) return; /* paket above max rate, clear current stats and montior again */ if (gTLRateInfo[rateIndex].phyRate >= pTLCb->gDsRxRoamStats.maxRate) { WLANTL_ClearAllRoamStats(pTLCb); /* Stop any PER based scan if going on */ pTLCb->gDsRxRoamStats. triggerRoamScanfn(pTLCb->gDsRxRoamStats.hHal, 0); return; } timeDifference = currentTime - pTLCb->gDsRxRoamStats.rxRoamStats[pTLCb->gDsRxRoamStats.index].time; if (timeDifference) incrementCnt = do_div(timeDifference, ROAM_PER_INDEX_TIME); /* More that ROAM_PER_INDEX_TIME has esclapsed, * fill data at new index */ if (incrementCnt) { if (incrementCnt > ROAM_MAX_INDEX_NUM) { /* * Clear all stats, these are older than * ROAM_MAX_INDEX_NUM * ROAM_PER_INDEX_TIME (Max buffer time) */ WLANTL_ClearAllRoamStats(pTLCb); pTLCb->gDsRxRoamStats.index = 0; } else WLANTL_ClearOldPERStats(pTLCb, incrementCnt); pTLCb->gDsRxRoamStats.rxRoamStats [pTLCb->gDsRxRoamStats.index].time = currentTime; } /* If pkt rate below minRate, increment low pkts counts */ if (gTLRateInfo[rateIndex].phyRate < pTLCb->gDsRxRoamStats.minRate) { pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index]. lowRateRxPacketsRcvd++; pTLCb->gDsRxRoamStats.lowRatePkt++; } /* Increment total pkts counts */ pTLCb->gDsRxRoamStats. rxRoamStats[pTLCb->gDsRxRoamStats.index].totalPktRcvd++; pTLCb->gDsRxRoamStats.totalPkt++; /* Check if we have reached threshold value to trigger a roam scan */ if ((pTLCb->gDsRxRoamStats.totalPkt != 0) && (pTLCb->gDsRxRoamStats.totalPkt > pTLCb->gDsRxRoamStats.minPktRequired)&& ((pTLCb->gDsRxRoamStats.lowRatePkt * 100) > (pTLCb->gDsRxRoamStats.totalPkt * pTLCb->gDsRxRoamStats.minPercentage))) { /* callback handler to trigger a roam scan */ if (pTLCb->gDsRxRoamStats.triggerRoamScanfn) pTLCb->gDsRxRoamStats. triggerRoamScanfn(pTLCb->gDsRxRoamStats.hHal, 1); VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_DEBUG, "PER Roam: triggerring roam scan totalPkt =%lu lowRatePkt %lu minPktRequired %u minPercentage %d", (long unsigned int) pTLCb->gDsRxRoamStats.totalPkt, (long unsigned int) pTLCb->gDsRxRoamStats.lowRatePkt, (unsigned int) pTLCb->gDsRxRoamStats.minPktRequired, pTLCb->gDsRxRoamStats.minPercentage); WLANTL_ClearAllRoamStats(pTLCb); /* save current time as last trigger time */ pTLCb->gDsRxRoamStats.lastTriggerTime = currentTime; } } #endif /*========================================================================== FUNCTION WLANTL_STARxAuth DESCRIPTION Receive in authenticated state - all data allowed DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the rx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STARxAuth ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; v_U8_t ucAsf; /* AMSDU sub frame */ v_U16_t usMPDUDOffset; v_U8_t ucMPDUHOffset; v_U16_t usMPDULen; v_U8_t ucMPDUHLen; v_U16_t usActualHLen = 0; v_U8_t ucTid; #ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD v_U8_t rxRate; v_U8_t type; #endif #ifdef FEATURE_WLAN_WAPI v_U16_t usEtherType = 0; tSirMacMgmtHdr *hdr; #endif v_U16_t usPktLen; vos_pkt_t* vosDataBuff ; v_PVOID_t aucBDHeader; VOS_STATUS vosStatus; WLANTL_RxMetaInfoType wRxMetaInfo; static v_U8_t ucPMPDUHLen; v_U32_t* STAMetaInfoPtr; v_U8_t ucEsf=0; /* first subframe of AMSDU flag */ v_U64_t ullcurrentReplayCounter=0; /*current replay counter*/ v_U64_t ullpreviousReplayCounter=0; /*previous replay counter*/ v_U16_t ucUnicastBroadcastType=0; /*It denotes whether received frame is UC or BC*/ struct _BARFrmStruct *pBarFrame = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if (( NULL == pvosDataBuff ) || ( NULL == ( vosDataBuff = *pvosDataBuff ))) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_STARxAuth")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_STARxAuth")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*------------------------------------------------------------------------ Extract BD header and check if valid ------------------------------------------------------------------------*/ WDA_DS_PeekRxPacketInfo( vosDataBuff, (v_PVOID_t)&aucBDHeader, 0 ); ucMPDUHOffset = (v_U8_t)WDA_GET_RX_MPDU_HEADER_OFFSET(aucBDHeader); usMPDUDOffset = (v_U16_t)WDA_GET_RX_MPDU_DATA_OFFSET(aucBDHeader); usMPDULen = (v_U16_t)WDA_GET_RX_MPDU_LEN(aucBDHeader); ucMPDUHLen = (v_U8_t)WDA_GET_RX_MPDU_HEADER_LEN(aucBDHeader); ucTid = (v_U8_t)WDA_GET_RX_TID(aucBDHeader); #ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD rxRate = (v_U8_t)WDA_GET_RX_MAC_RATE_IDX(aucBDHeader); type = (v_U8_t)WDA_GET_RX_TYPE(aucBDHeader); #endif pClientSTA->rate_idx = (v_U8_t)WDA_GET_RX_MAC_RATE_IDX(aucBDHeader); /* Fix for a hardware bug. * H/W does not update the tid field in BD header for BAR frames. * Fix is to read the tid field from MAC header of BAR frame */ if( (WDA_GET_RX_TYPE(aucBDHeader) == SIR_MAC_CTRL_FRAME) && (WDA_GET_RX_SUBTYPE(aucBDHeader) == SIR_MAC_CTRL_BAR)) { pBarFrame = (struct _BARFrmStruct *)(WDA_GET_RX_MAC_HEADER(aucBDHeader)); ucTid = pBarFrame->barControl.numTID; } /*Host based replay check is needed for unicast data frames*/ ucUnicastBroadcastType = (v_U16_t)WDA_IS_RX_BCAST(aucBDHeader); if(0 != ucMPDUHLen) { ucPMPDUHLen = ucMPDUHLen; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:BD header processing data: HO %d DO %d Len %d HLen %d" " Tid %d BD %d", ucMPDUHOffset, usMPDUDOffset, usMPDULen, ucMPDUHLen, ucTid, WLANHAL_RX_BD_HEADER_SIZE)); vos_pkt_get_packet_length( vosDataBuff, &usPktLen); if ( VOS_STATUS_SUCCESS != WDA_DS_TrimRxPacketInfo( vosDataBuff ) ) { if((WDA_GET_RX_ASF(aucBDHeader) && !WDA_GET_RX_ESF(aucBDHeader))) { /* AMSDU case, ucMPDUHOffset = 0 * it should be hancdled seperatly */ if(( usMPDUDOffset > ucMPDUHOffset ) && ( usMPDULen >= ucMPDUHLen ) && ( usPktLen >= usMPDULen ) && ( !WLANTL_TID_INVALID(ucTid) )) { ucMPDUHOffset = usMPDUDOffset - WLANTL_MPDU_HEADER_LEN; } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:BD header corrupted - dropping packet")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:BD header corrupted - dropping packet")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } } #ifdef WLAN_FEATURE_RMC if (pTLCb->multicastDuplicateDetectionEnabled && (WLAN_STA_IBSS == pClientSTA->wSTADesc.wSTAType) && WLANTL_IS_DATA_FRAME(WDA_GET_RX_TYPE_SUBTYPE(aucBDHeader))) { /* * Multicast duplicate detection is only for frames received in * IBSS mode. */ if (VOS_TRUE == WLANTL_IsDuplicateMcastFrm(pClientSTA, vosDataBuff)) { pTLCb->mcastDupCnt++; /* Duplicate multicast data packet, drop the packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } } #endif /* WLAN_FEATURE_RMC */ #ifdef FEATURE_WLAN_WAPI if ( pClientSTA->wSTADesc.ucIsWapiSta ) { vosStatus = WLANTL_GetEtherType(aucBDHeader, vosDataBuff, ucMPDUHLen, &usEtherType); if( VOS_IS_STATUS_SUCCESS(vosStatus) ) { if ( WLANTL_LLC_WAI_TYPE == usEtherType ) { hdr = WDA_GET_RX_MAC_HEADER(aucBDHeader); if ( hdr->fc.wep ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:WAI frame was received encrypted - dropping")); /* Drop packet */ /*Temporary fix added to fix wapi rekey issue*/ vos_pkt_return_packet(vosDataBuff); return vosStatus; //returning success } } else { if ( WLANHAL_RX_IS_UNPROTECTED_WPI_FRAME(aucBDHeader) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Non-WAI frame was received unencrypted - dropping")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return vosStatus; //returning success } } } else //could not extract EtherType - this should not happen { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Could not extract EtherType")); //Packet is already freed return vosStatus; //returning failure } } #endif /* FEATURE_WLAN_WAPI */ /*---------------------------------------------------------------------- Increment receive counter !! not sure this is the best place to increase this - pkt might be dropped below or delayed in TL's queues - will leave it here for now ------------------------------------------------------------------------*/ if ( !WLANTL_TID_INVALID( ucTid) ) { pClientSTA->auRxCount[ucTid]++; } else { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid tid %d (Station ID %d) on %s", ucTid, ucSTAId, __func__)); vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_E_FAILURE; } #ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD if (pTLCb->gDsRxRoamStats.running && (ucSTAId == pTLCb->gDsRxRoamStats.staId) && (rxRate < WLANTL_MAX_RATE_NUM) && (type == SIR_MAC_DATA_FRAME)) { WLANTL_updatePERStats(pTLCb, rxRate); } #endif /*------------------------------------------------------------------------ Check if AMSDU and send for processing if so ------------------------------------------------------------------------*/ ucAsf = (v_U8_t)WDA_GET_RX_ASF(aucBDHeader); if ( 0 != ucAsf ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Packet is AMSDU sub frame - sending for completion")); vosStatus = WLANTL_AMSDUProcess( pvosGCtx, &vosDataBuff, aucBDHeader, ucSTAId, ucMPDUHLen, usMPDULen ); if(NULL == vosDataBuff) { //Packet is already freed return VOS_STATUS_SUCCESS; } } /* After AMSDU header handled * AMSDU frame just same with normal frames */ /*------------------------------------------------------------------- Translating header if necesary !! Fix me: rmv comments below ----------------------------------------------------------------------*/ if (( 0 == WDA_GET_RX_FT_DONE(aucBDHeader) ) && ( 0 != pClientSTA->wSTADesc.ucSwFrameRXXlation) && ( WLANTL_IS_DATA_FRAME(WDA_GET_RX_TYPE_SUBTYPE(aucBDHeader)) )) { if(0 == ucMPDUHLen) { ucMPDUHLen = ucPMPDUHLen; } if (usMPDUDOffset > ucMPDUHOffset) { usActualHLen = usMPDUDOffset - ucMPDUHOffset; } vosStatus = WLANTL_Translate80211To8023Header( vosDataBuff, &vosStatus, usActualHLen, ucMPDUHLen, pTLCb, ucSTAId, bForwardIAPPwithLLC); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL:Failed to translate from 802.11 to 802.3 - dropping")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); return vosStatus; } } /* Softap requires additional Info such as Destination STAID and Access Category. Voschain or Buffer returned by BA would be unchain and this Meta Data would help in routing the packets to appropriate Destination */ if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType) { STAMetaInfoPtr = (v_U32_t *)(uintptr_t)(ucTid | (WDA_GET_RX_ADDR3_IDX(aucBDHeader) << WLANTL_STAID_OFFSET)); vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)STAMetaInfoPtr); } /* Check to see if re-ordering session is in place. Skip add to reorder list for TDLS packet on AP staid*/ if (0 != pClientSTA->atlBAReorderInfo[ucTid].ucExists && !vosDataBuff->pn_replay_skip) { WLANTL_MSDUReorder( pTLCb, &vosDataBuff, aucBDHeader, ucSTAId, ucTid ); } if(WLANTL_IS_DATA_FRAME(WDA_GET_RX_TYPE_SUBTYPE(aucBDHeader)) && (0 == ucUnicastBroadcastType) #ifdef FEATURE_ON_CHIP_REORDERING && (WLANHAL_IsOnChipReorderingEnabledForTID(pvosGCtx, ucSTAId, ucTid) != TRUE) #endif ) { /* replay check code : check whether replay check is needed or not Skip replay check for TDLS traffic with AP sta id */ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid) { /* replay check is needed for the station */ /* check whether frame is AMSDU frame */ if ( 0 != ucAsf ) { /* Since virgo can't send AMSDU frames this leg of the code was not tested properly, it needs to be tested properly*/ /* Frame is AMSDU frame. As per 802.11n only first subframe will have replay counter */ ucEsf = WDA_GET_RX_ESF( aucBDHeader ); if( 0 != ucEsf ) { v_BOOL_t status; /* Getting 48-bit replay counter from the RX BD */ ullcurrentReplayCounter = WDA_DS_GetReplayCounter(aucBDHeader); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: AMSDU currentReplayCounter [0x%llX]",ullcurrentReplayCounter); /* Getting 48-bit previous replay counter from TL control block */ ullpreviousReplayCounter = pClientSTA->ullReplayCounter[ucTid]; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: AMSDU previousReplayCounter [0x%llX]",ullpreviousReplayCounter); /* It is first subframe of AMSDU thus it conatains replay counter perform the replay check for this first subframe*/ status = WLANTL_IsReplayPacket( ullcurrentReplayCounter, ullpreviousReplayCounter); if(VOS_FALSE == status) { /* Not a replay paket, update previous replay counter in TL CB */ pClientSTA->ullReplayCounter[ucTid] = ullcurrentReplayCounter; } else { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: AMSDU Drop the replay packet with PN : [0x%llX]",ullcurrentReplayCounter); pClientSTA->ulTotalReplayPacketsDetected++; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: AMSDU total dropped replay packets on STA ID %X is [0x%X]", ucSTAId, pClientSTA->ulTotalReplayPacketsDetected); /* Drop the packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } } } else { v_BOOL_t status; uint16_t seq_no = (uint16_t)WDA_GET_RX_REORDER_CUR_PKT_SEQ_NO(aucBDHeader); /* Getting 48-bit replay counter from the RX BD */ ullcurrentReplayCounter = WDA_DS_GetReplayCounter(aucBDHeader); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Non-AMSDU currentReplayCounter [0x%llX]",ullcurrentReplayCounter); /* Getting 48-bit previous replay counter from TL control block */ ullpreviousReplayCounter = pClientSTA->ullReplayCounter[ucTid]; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Non-AMSDU previousReplayCounter [0x%llX]",ullpreviousReplayCounter); /* It is not AMSDU frame so perform reaply check for each packet, as each packet contains valid replay counter*/ if (vosDataBuff != NULL && !vosDataBuff->pn_replay_skip) { if (vos_is_pkt_chain(vosDataBuff)) { WLANTL_ReorderReplayCheck(pClientSTA, &vosDataBuff, ucTid); } else { status = WLANTL_IsReplayPacket(ullcurrentReplayCounter, ullpreviousReplayCounter); if(VOS_FALSE == status) { /* Not a replay paket, update previous replay counter in TL CB */ pClientSTA->ullReplayCounter[ucTid] = ullcurrentReplayCounter; pClientSTA->last_seq_no[ucTid] = seq_no; } else { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Non AMSDU Drop replay with PN: [0x%llX], prevPN: [0x%llx]" " seq_no:%d last_seq_no:%d", ullcurrentReplayCounter, ullpreviousReplayCounter, seq_no, pClientSTA->last_seq_no[ucTid]); pClientSTA->ulTotalReplayPacketsDetected++; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Non AMSDU total dropped replay packets on STA ID %X is [0x%X]", ucSTAId, pClientSTA->ulTotalReplayPacketsDetected); /* Repaly packet, drop the packet */ vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; } } } } } } /*It is a broadast packet DPU has already done replay check for broadcast packets no need to do replay check of these packets*/ if ( NULL != vosDataBuff ) { if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType) { WLANTL_FwdPktToHDD( pvosGCtx, vosDataBuff, ucSTAId ); } else { wRxMetaInfo.ucUP = ucTid; wRxMetaInfo.rssiAvg = pClientSTA->rssiAvg; #ifdef FEATURE_WLAN_TDLS if (WLAN_STA_TDLS == pClientSTA->wSTADesc.wSTAType) { wRxMetaInfo.isStaTdls = TRUE; } else { wRxMetaInfo.isStaTdls = FALSE; } #endif pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId, &wRxMetaInfo ); } }/* if not NULL */ return VOS_STATUS_SUCCESS; }/* WLANTL_STARxAuth */ /*========================================================================== FUNCTION WLANTL_STARxDisc DESCRIPTION Receive in disconnected state - no data allowed DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station being processed vosDataBuff: pointer to the rx vos buffer RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_STARxDisc ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, vos_pkt_t** pvosDataBuff, v_BOOL_t bForwardIAPPwithLLC ) { /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if (( NULL == pvosDataBuff ) || ( NULL == *pvosDataBuff )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_STARxDisc")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Error - drop packet ------------------------------------------------------------------------*/ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Packet should not be received in state disconnected" " - dropping")); vos_pkt_return_packet(*pvosDataBuff); *pvosDataBuff = NULL; return VOS_STATUS_SUCCESS; }/* WLANTL_STARxDisc */ /*========================================================================== Processing main loops for MAIN and TX threads ==========================================================================*/ /*========================================================================== FUNCTION WLANTL_McProcessMsg DESCRIPTION Called by VOSS when a message was serialized for TL through the main thread/task. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context message: type and content of the message RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_McProcessMsg ( v_PVOID_t pvosGCtx, vos_msg_t* message ) { WLANTL_CbType* pTLCb = NULL; tAddBAInd* ptAddBaInd = NULL; tDelBAInd* ptDelBaInd = NULL; tAddBARsp* ptAddBaRsp = NULL; vos_msg_t vosMessage; VOS_STATUS vosStatus; tpFlushACRsp FlushACRspPtr; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == message ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_ProcessMainMessage")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ProcessMainMessage")); return VOS_STATUS_E_FAULT; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Received message: %d through main flow", message->type)); switch( message->type ) { case WDA_TL_FLUSH_AC_RSP: // Extract the message from the message body FlushACRspPtr = (tpFlushACRsp)(message->bodyptr); // Make sure the call back function is not null. if ( NULL == pTLCb->tlBAPClient.pfnFlushOpCompleteCb ) { VOS_ASSERT(0); TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer pfnFlushOpCompleteCb")); return VOS_STATUS_E_FAULT; } TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Received message: Flush complete received by TL")); // Since we have the response back from HAL, just call the BAP client // registered call back from TL. There is only 1 possible // BAP client. So directly reference tlBAPClient pTLCb->tlBAPClient.pfnFlushOpCompleteCb( pvosGCtx, FlushACRspPtr->ucSTAId, FlushACRspPtr->ucTid, FlushACRspPtr->status ); // Free the PAL memory, we are done with it. TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Flush complete received by TL: Freeing %pK", FlushACRspPtr)); vos_mem_free((v_VOID_t *)FlushACRspPtr); break; case WDA_HDD_ADDBA_REQ: ptAddBaInd = (tAddBAInd*)(message->bodyptr); vosStatus = WLANTL_BaSessionAdd( pvosGCtx, ptAddBaInd->baSession.baSessionID, ptAddBaInd->baSession.STAID, ptAddBaInd->baSession.baTID, (v_U32_t)ptAddBaInd->baSession.baBufferSize, ptAddBaInd->baSession.winSize, ptAddBaInd->baSession.SSN); ptAddBaRsp = vos_mem_malloc(sizeof(*ptAddBaRsp)); if ( NULL == ptAddBaRsp ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: fatal failure, cannot allocate BA Rsp structure")); VOS_ASSERT(0); return VOS_STATUS_E_NOMEM; } if ( VOS_STATUS_SUCCESS == vosStatus ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Sending success indication to HAL for ADD BA")); /*Send success*/ ptAddBaRsp->mesgType = WDA_HDD_ADDBA_RSP; vosMessage.type = WDA_HDD_ADDBA_RSP; } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Sending failure indication to HAL for ADD BA")); /*Send failure*/ ptAddBaRsp->mesgType = WDA_BA_FAIL_IND; vosMessage.type = WDA_BA_FAIL_IND; } ptAddBaRsp->mesgLen = sizeof(tAddBARsp); ptAddBaRsp->baSessionID = ptAddBaInd->baSession.baSessionID; /* This is default, reply win size has to be handled BA module, FIX THIS */ ptAddBaRsp->replyWinSize = WLANTL_MAX_WINSIZE; vosMessage.bodyptr = ptAddBaRsp; vos_mq_post_message( VOS_MQ_ID_WDA, &vosMessage ); WLANTL_McFreeMsg (pvosGCtx, message); break; case WDA_DELETEBA_IND: ptDelBaInd = (tDelBAInd*)(message->bodyptr); vosStatus = WLANTL_BaSessionDel(pvosGCtx, ptDelBaInd->staIdx, ptDelBaInd->baTID); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to del BA session STA:%d TID:%d Status :%d", ptDelBaInd->staIdx, ptDelBaInd->baTID, vosStatus)); } WLANTL_McFreeMsg (pvosGCtx, message); break; default: /*no processing for now*/ break; } return VOS_STATUS_SUCCESS; }/* WLANTL_ProcessMainMessage */ /*========================================================================== FUNCTION WLANTL_McFreeMsg DESCRIPTION Called by VOSS to free a given TL message on the Main thread when there are messages pending in the queue when the whole system is been reset. For now, TL does not allocate any body so this function shout translate into a NOOP DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context message: type and content of the message RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_McFreeMsg ( v_PVOID_t pvosGCtx, vos_msg_t* message ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == message ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_McFreeMsg")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_McFreeMsg")); return VOS_STATUS_E_FAULT; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Received message: %d through main free", message->type)); switch( message->type ) { case WDA_HDD_ADDBA_REQ: case WDA_DELETEBA_IND: /*vos free body pointer*/ vos_mem_free(message->bodyptr); message->bodyptr = NULL; break; default: /*no processing for now*/ break; } return VOS_STATUS_SUCCESS; }/*WLANTL_McFreeMsg*/ /*========================================================================== FUNCTION WLANTL_TxProcessMsg DESCRIPTION Called by VOSS when a message was serialized for TL through the tx thread/task. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context message: type and content of the message RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other values can be returned as a result of a function call, please check corresponding API for more info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_TxProcessMsg ( v_PVOID_t pvosGCtx, vos_msg_t* message ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; void (*callbackRoutine) (void *callbackContext); void *callbackContext; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == message ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_ProcessTxMessage")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Process message ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Received message: %d through tx flow", message->type)); switch( message->type ) { case WLANTL_TX_SIG_SUSPEND: vosStatus = WLANTL_SuspendCB( pvosGCtx, (WLANTL_SuspendCBType)message->bodyptr, message->reserved); break; case WLANTL_TX_RES_NEEDED: vosStatus = WLANTL_GetTxResourcesCB( pvosGCtx ); break; case WDA_DS_TX_START_XMIT: WLANTL_ClearTxXmitPending(pvosGCtx); vosStatus = WDA_DS_TxFrames( pvosGCtx ); break; case WDA_DS_FINISH_ULA: callbackContext = message->bodyptr; callbackRoutine = message->callback; if ( NULL != callbackRoutine ) { callbackRoutine(callbackContext); } break; case WLANTL_TX_SNAPSHOT: /*Dumping TL State and then continuing to print the DXE Dump*/ WLANTL_TxThreadDebugHandler(pvosGCtx); WDA_TransportChannelDebug(NULL, VOS_TRUE, VOS_FALSE); break; case WLANTL_TX_FATAL_ERROR: WLANTL_FatalErrorHandler(pvosGCtx); break; case WLANTL_TX_FW_DEBUG: vos_fwDumpReq(274, 0, 0, 0, 0, 1); //Async event break; case WLANTL_TX_KICKDXE: WDA_TransportKickDxe(); break; default: /*no processing for now*/ break; } return vosStatus; }/* WLANTL_TxProcessMsg */ /*========================================================================== FUNCTION WLANTL_McFreeMsg DESCRIPTION Called by VOSS to free a given TL message on the Main thread when there are messages pending in the queue when the whole system is been reset. For now, TL does not allocate any body so this function shout translate into a NOOP DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context message: type and content of the message RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_TxFreeMsg ( v_PVOID_t pvosGCtx, vos_msg_t* message ) { /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*Nothing to do for now!!!*/ return VOS_STATUS_SUCCESS; }/*WLANTL_TxFreeMsg*/ /*========================================================================== FUNCTION WLANTL_TxFCFrame DESCRIPTION Internal utility function to send FC frame. Enable or disable LWM mode based on the information. DEPENDENCIES TL must be initiailized before this function gets called. FW sends up special flow control frame. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input pointers are NULL. VOS_STATUS_E_FAULT: Something is wrong. VOS_STATUS_SUCCESS: Everything is good. SIDE EFFECTS Newly formed FC frame is generated and waits to be transmitted. Previously unsent frame will be released. ============================================================================*/ VOS_STATUS WLANTL_TxFCFrame ( v_PVOID_t pvosGCtx ) { #if 0 WLANTL_CbType* pTLCb = NULL; VOS_STATUS vosStatus; tpHalFcTxBd pvFcTxBd = NULL; vos_pkt_t * pPacket = NULL; v_U8_t ucSTAId = 0; v_U8_t ucBitCheck = 1; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Send FC frame %s", __func__); /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pvosGCtx ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter %s", __func__)); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid pointer in %s \n", __func__)); return VOS_STATUS_E_INVAL; } //Get one voss packet vosStatus = vos_pkt_get_packet( &pPacket, VOS_PKT_TYPE_TX_802_11_MGMT, sizeof(tHalFcTxBd), 1, VOS_FALSE, NULL, NULL ); if ( VOS_STATUS_SUCCESS != vosStatus ) { return VOS_STATUS_E_INVAL; } vosStatus = vos_pkt_reserve_head( pPacket, (void *)&pvFcTxBd, sizeof(tHalFcTxBd)); if( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: failed to reserve FC TX BD %d\n",__func__, sizeof(tHalFcTxBd))); vos_pkt_return_packet( pPacket ); return VOS_STATUS_E_FAULT; } //Generate most recent tlFCInfo. Most fields are correct. pTLCb->tlFCInfo.fcSTAThreshEnabledMask = 0; pTLCb->tlFCInfo.fcSTATxMoreDataMask = 0; for( ucSTAId = 0, ucBitCheck = 1 ; ucSTAId < WLAN_MAX_STA_COUNT; ucBitCheck <<= 1, ucSTAId ++) { if (0 == pTLCb->atlSTAClients[ucSTAId].ucExists) { continue; } if (pTLCb->atlSTAClients[ucSTAId].ucPktPending) { pTLCb->tlFCInfo.fcSTATxMoreDataMask |= ucBitCheck; } if ( (pTLCb->atlSTAClients[ucSTAId].ucLwmModeEnabled) && (pTLCb->atlSTAClients[ucSTAId].bmuMemConsumed > pTLCb->atlSTAClients[ucSTAId].uLwmThreshold)) { pTLCb->tlFCInfo.fcSTAThreshEnabledMask |= ucBitCheck; pTLCb->tlFCInfo.fcSTAThresh[ucSTAId] = (tANI_U8)pTLCb->atlSTAClients[ucSTAId].uLwmThreshold; pTLCb->atlSTAClients[ucSTAId].ucLwmEventReported = FALSE; } } //request immediate feedback pTLCb->tlFCInfo.fcConfig |= 0x4; //fill in BD to sent vosStatus = WLANHAL_FillFcTxBd(pvosGCtx, &pTLCb->tlFCInfo, (void *)pvFcTxBd); if( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Fill FC TX BD unsuccessful\n", __func__)); vos_pkt_return_packet( pPacket ); return VOS_STATUS_E_FAULT; } if (NULL != pTLCb->vosTxFCBuf) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s: Previous FC TX BD not sent\n", __func__)); vos_pkt_return_packet(pTLCb->vosTxFCBuf); } pTLCb->vosTxFCBuf = pPacket; vos_pkt_set_user_data_ptr( pPacket, VOS_PKT_USER_DATA_ID_TL, (v_PVOID_t)WLANTL_TxCompDefaultCb); vosStatus = WDA_DS_StartXmit(pvosGCtx); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: send FC frame leave %s", __func__)); #endif return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION WLANTL_GetTxResourcesCB DESCRIPTION Processing function for Resource needed signal. A request will be issued to BAL to get more tx resources. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other values can be returned as a result of a function call, please check corresponding API for more info. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetTxResourcesCB ( v_PVOID_t pvosGCtx ) { WLANTL_CbType* pTLCb = NULL; v_U32_t uResCount = WDA_TLI_MIN_RES_DATA; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_U8_t ucMgmt = 0; v_U8_t ucBAP = 0; v_U8_t ucData = 0; #ifdef WLAN_SOFTAP_FLOWCTRL_EN tBssSystemRole systemRole; tpAniSirGlobal pMac; #endif /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on" " WLANTL_ProcessTxMessage")); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Get tx resources from BAL ------------------------------------------------------------------------*/ vosStatus = WDA_DS_GetTxResources( pvosGCtx, &uResCount ); if ( (VOS_STATUS_SUCCESS != vosStatus) && (VOS_STATUS_E_RESOURCES != vosStatus)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:TL failed to get resources from BAL, Err: %d", vosStatus)); return vosStatus; } /* Currently only Linux BAL returns the E_RESOURCES error code when it is running out of BD/PDUs. To make use of this interrupt for throughput enhancement, similar changes should be done in BAL code of AMSS and WM */ if (VOS_STATUS_E_RESOURCES == vosStatus) { #ifdef VOLANS_PERF WLANHAL_EnableIdleBdPduInterrupt(pvosGCtx, (tANI_U8)bdPduInterruptGetThreshold); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Enabling Idle BD/PDU interrupt, Current resources = %d", uResCount); #else return VOS_STATUS_E_FAILURE; #endif } pTLCb->uResCount = uResCount; #ifdef WLAN_SOFTAP_FLOWCTRL_EN /* FIXME: disabled since creating issues in power-save, needs to be addressed */ pTLCb->sendFCFrame ++; pMac = vos_get_context(VOS_MODULE_ID_WDA, pvosGCtx); systemRole = wdaGetGlobalSystemRole(pMac); if (eSYSTEM_AP_ROLE == systemRole) { if (pTLCb->sendFCFrame % 16 == 0) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Transmit FC")); WLANTL_TxFCFrame (pvosGCtx); } } #endif //WLAN_SOFTAP_FLOWCTRL_EN ucData = ( pTLCb->uResCount >= WDA_TLI_MIN_RES_DATA ); ucBAP = ( pTLCb->uResCount >= WDA_TLI_MIN_RES_BAP ) && ( NULL != pTLCb->tlBAPClient.vosPendingDataBuff ); ucMgmt = ( pTLCb->uResCount >= WDA_TLI_MIN_RES_MF ) && ( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff ); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Eval Resume tx Res: %d DATA: %d BAP: %d MGMT: %d", pTLCb->uResCount, ucData, ucBAP, ucMgmt)); if (( 0 == pTLCb->ucTxSuspended ) && (( 0 != ucData ) || ( 0 != ucMgmt ) || ( 0 != ucBAP ) ) ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Issuing Xmit start request to BAL for avail res SYNC")); vosStatus =WDA_DS_StartXmit(pvosGCtx); } return vosStatus; }/*WLANTL_GetTxResourcesCB*/ /*========================================================================== Utility functions ==========================================================================*/ /*========================================================================== FUNCTION WLANTL_Translate8023To80211Header DESCRIPTION Inline function for translating and 802.11 header into an 802.3 header. DEPENDENCIES PARAMETERS IN pTLCb: TL control block IN/OUT ucStaId: station ID. Incase of TDLS, this returns actual TDLS station ID used IN/OUT vosDataBuff: vos data buffer, will contain the new header on output OUT pvosStatus: status of the operation RETURN VALUE VOS_STATUS_SUCCESS: Everything is good :) Other error codes might be returned from the vos api used in the function please check those return values. SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Translate8023To80211Header ( vos_pkt_t* vosDataBuff, VOS_STATUS* pvosStatus, WLANTL_CbType* pTLCb, v_U8_t *pucStaId, WLANTL_MetaInfoType *tlMetaInfo, v_U8_t *ucWDSEnabled, v_U8_t *extraHeadSpace ) { WLANTL_8023HeaderType w8023Header; WLANTL_80211HeaderType *pw80211Header; // Allocate an aligned BD and then fill it. VOS_STATUS vosStatus; v_U8_t MandatoryucHeaderSize = WLAN80211_MANDATORY_HEADER_SIZE; v_U8_t ucHeaderSize = 0; v_VOID_t *ppvBDHeader = NULL; WLANTL_STAClientType* pClientSTA = NULL; v_U8_t ucQoSOffset = WLAN80211_MANDATORY_HEADER_SIZE; v_U8_t ucStaId; #ifdef FEATURE_WLAN_ESE_UPLOAD v_BOOL_t bIAPPTxwithLLC = VOS_FALSE; v_SIZE_t wIAPPSnapSize = WLANTL_LLC_HEADER_LEN; v_U8_t wIAPPSnap[WLANTL_LLC_HEADER_LEN] = {0}; #endif *ucWDSEnabled = 0; // default WDS off. vosStatus = vos_pkt_pop_head( vosDataBuff, &w8023Header, sizeof(w8023Header)); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Packet pop header fails on WLANTL_Translate8023To80211Header")); return vosStatus; } if( NULL == pucStaId ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Invalid pointer for StaId")); return VOS_STATUS_E_INVAL; } ucStaId = *pucStaId; pClientSTA = pTLCb->atlSTAClients[ucStaId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } #ifdef FEATURE_WLAN_TDLS if ( WLAN_STA_INFRA == pTLCb->atlSTAClients[ucStaId]->wSTADesc.wSTAType && pTLCb->ucTdlsPeerCount ) { v_U8_t ucIndex = 0; for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT ; ucIndex++) { if ( ucIndex != ucStaId && pTLCb->atlSTAClients[ucIndex] && pTLCb->atlSTAClients[ucIndex]->ucExists && (pTLCb->atlSTAClients[ucIndex]->tlState == WLANTL_STA_AUTHENTICATED) && (!pTLCb->atlSTAClients[ucIndex]->ucTxSuspended) && vos_mem_compare( (void*)pTLCb->atlSTAClients[ucIndex]->wSTADesc.vSTAMACAddress.bytes, (void*)w8023Header.vDA, 6) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, "WLAN TL: Got a TDLS station. Using that index")); ucStaId = ucIndex; *pucStaId = ucStaId; pClientSTA = pTLCb->atlSTAClients[ucStaId]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } break; } } } #endif #ifdef FEATURE_WLAN_ESE_UPLOAD if ((0 == w8023Header.usLenType) && (pClientSTA->wSTADesc.ucIsEseSta)) { vos_pkt_extract_data(vosDataBuff,0,&wIAPPSnap[0],&wIAPPSnapSize); if (vos_mem_compare(wIAPPSnap,WLANTL_AIRONET_SNAP_HEADER,WLANTL_LLC_HEADER_LEN)) { /*The SNAP and the protocol type are already in the data buffer. They are filled by the application (wpa_supplicant). So, Skip Adding LLC below.*/ bIAPPTxwithLLC = VOS_TRUE; } else { bIAPPTxwithLLC = VOS_FALSE; } } #endif /* FEATURE_WLAN_ESE_UPLOAD */ if ((0 != pClientSTA->wSTADesc.ucAddRmvLLC) #ifdef FEATURE_WLAN_ESE_UPLOAD && (!bIAPPTxwithLLC) #endif /* FEATURE_WLAN_ESE_UPLOAD */ ) { /* Push the length */ vosStatus = vos_pkt_push_head(vosDataBuff, &w8023Header.usLenType, sizeof(w8023Header.usLenType)); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Packet push ether type fails on" " WLANTL_Translate8023To80211Header")); return vosStatus; } #ifdef BTAMP_TEST // The STA side will execute this, a hack to test BTAMP by using the // infra setup. On real BTAMP this will come from BAP itself. { static v_U8_t WLANTL_BT_AMP_LLC_HEADER[] = {0xAA, 0xAA, 0x03, 0x00, 0x19, 0x58 }; vosStatus = vos_pkt_push_head(vosDataBuff, WLANTL_BT_AMP_LLC_HEADER, sizeof(WLANTL_BT_AMP_LLC_HEADER)); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Packet push LLC header fails on" " WLANTL_Translate8023To80211Header")); return vosStatus; } } #else vosStatus = vos_pkt_push_head(vosDataBuff, WLANTL_LLC_HEADER, sizeof(WLANTL_LLC_HEADER)); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Packet push LLC header fails on" " WLANTL_Translate8023To80211Header")); return vosStatus; } #endif }/*If add LLC is enabled*/ else { #ifdef FEATURE_WLAN_ESE_UPLOAD bIAPPTxwithLLC = VOS_FALSE; /*Reset the Flag here to start afresh with the next TX pkt*/ #endif /* FEATURE_WLAN_ESE_UPLOAD */ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: STA Client registered to not remove LLC" " WLANTL_Translate8023To80211Header")); } #ifdef BTAMP_TEST pClientSTA->wSTADesc.wSTAType = WLAN_STA_BT_AMP; #endif // Find the space required for the 802.11 header format // based on the frame control fields. ucHeaderSize = MandatoryucHeaderSize; if (pClientSTA->wSTADesc.ucQosEnabled) { ucHeaderSize += sizeof(pw80211Header->usQosCtrl); } if (pClientSTA->wSTADesc.wSTAType == WLAN_STA_BT_AMP) { ucHeaderSize += sizeof(pw80211Header->optvA4); ucQoSOffset += sizeof(pw80211Header->optvA4); } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, " WLANTL_Translate8023To80211Header : Header size = %d ", ucHeaderSize)); vos_pkt_reserve_head( vosDataBuff, &ppvBDHeader, ucHeaderSize ); if ( NULL == ppvBDHeader ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:VOSS packet corrupted ")); *pvosStatus = VOS_STATUS_E_INVAL; return *pvosStatus; } // OK now we have the space. Fill the 80211 header /* Fill A2 */ pw80211Header = (WLANTL_80211HeaderType *)(ppvBDHeader); // only clear the required space. vos_mem_set( pw80211Header, ucHeaderSize, 0 ); vos_mem_copy( pw80211Header->vA2, w8023Header.vSA, VOS_MAC_ADDR_SIZE); #ifdef FEATURE_WLAN_WAPI if (( WLANTL_STA_AUTHENTICATED == pClientSTA->tlState || pClientSTA->ptkInstalled ) && (tlMetaInfo->ucIsWai != 1)) #else if ( WLANTL_STA_AUTHENTICATED == pClientSTA->tlState || pClientSTA->ptkInstalled ) #endif { pw80211Header->wFrmCtrl.wep = pClientSTA->wSTADesc.ucProtectedFrame; } pw80211Header->usDurationId = 0; pw80211Header->usSeqCtrl = 0; pw80211Header->wFrmCtrl.type = WLANTL_80211_DATA_TYPE; if(pClientSTA->wSTADesc.ucQosEnabled) { pw80211Header->wFrmCtrl.subType = WLANTL_80211_DATA_QOS_SUBTYPE; *((v_U16_t *)((v_U8_t *)ppvBDHeader + ucQoSOffset)) = tlMetaInfo->ucUP; } else { pw80211Header->wFrmCtrl.subType = 0; tlMetaInfo->ucUP = 0; tlMetaInfo->ucTID = 0; // NO NO NO - there is not enough memory allocated to write the QOS ctrl // field, it will overwrite the first 2 bytes of the data packet(LLC header) // pw80211Header->usQosCtrl = 0; } switch( pClientSTA->wSTADesc.wSTAType ) { case WLAN_STA_IBSS: pw80211Header->wFrmCtrl.toDS = 0; pw80211Header->wFrmCtrl.fromDS = 0; vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1, (v_MACADDR_t*)&w8023Header.vDA); vos_mem_copy( pw80211Header->vA3, &pClientSTA->wSTADesc.vBSSIDforIBSS , VOS_MAC_ADDR_SIZE); break; case WLAN_STA_BT_AMP: *ucWDSEnabled = 1; // WDS on. pw80211Header->wFrmCtrl.toDS = 1; pw80211Header->wFrmCtrl.fromDS = 1; vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1, &pClientSTA->wSTADesc.vSTAMACAddress); vos_mem_copy( pw80211Header->vA2, w8023Header.vSA, VOS_MAC_ADDR_SIZE); vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA3, &pClientSTA->wSTADesc.vSTAMACAddress); /* fill the optional A4 header */ vos_mem_copy( pw80211Header->optvA4, w8023Header.vSA, VOS_MAC_ADDR_SIZE); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "BTAMP CASE NOW ---------staid=%d", ucStaId)); break; case WLAN_STA_SOFTAP: *ucWDSEnabled = 0; // WDS off. pw80211Header->wFrmCtrl.toDS = 0; pw80211Header->wFrmCtrl.fromDS = 1; /*Copy the DA to A1*/ vos_mem_copy( pw80211Header->vA1, w8023Header.vDA , VOS_MAC_ADDR_SIZE); vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA2, &pClientSTA->wSTADesc.vSelfMACAddress); vos_mem_copy( pw80211Header->vA3, w8023Header.vSA, VOS_MAC_ADDR_SIZE); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "sw 802 to 80211 softap case ---------staid=%d", ucStaId)); break; #ifdef FEATURE_WLAN_TDLS case WLAN_STA_TDLS: pw80211Header->wFrmCtrl.toDS = 0; pw80211Header->wFrmCtrl.fromDS = 0; /*Fix me*/ vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1, &pClientSTA->wSTADesc.vSTAMACAddress); vos_mem_copy( pw80211Header->vA3, &pClientSTA->wSTADesc.vBSSIDforIBSS , VOS_MAC_ADDR_SIZE); VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, ("TL:TDLS CASE NOW ---------staid=%d"), ucStaId); break; #endif case WLAN_STA_INFRA: default: pw80211Header->wFrmCtrl.toDS = 1; pw80211Header->wFrmCtrl.fromDS = 0; vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1, &pClientSTA->wSTADesc.vSTAMACAddress); vos_mem_copy( pw80211Header->vA3, w8023Header.vDA , VOS_MAC_ADDR_SIZE); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "REGULAR INFRA LINK CASE---------staid=%d", ucStaId)); break; } // OK now we have the space. Fill the 80211 header /* Fill A2 */ pw80211Header = (WLANTL_80211HeaderType *)(ppvBDHeader); return VOS_STATUS_SUCCESS; }/*WLANTL_Translate8023To80211Header*/ /*============================================================================= BEGIN LOG FUNCTION !!! Remove me or clean me =============================================================================*/ #if 0 //def WLANTL_DEBUG #define WLANTL_DEBUG_FRAME_BYTE_PER_LINE 16 #define WLANTL_DEBUG_FRAME_BYTE_PER_BYTE 4 static v_VOID_t WLANTL_DebugFrame ( v_PVOID_t dataPointer, v_U32_t dataSize ) { v_U8_t lineBuffer[WLANTL_DEBUG_FRAME_BYTE_PER_LINE]; v_U32_t numLines; v_U32_t numBytes; v_U32_t idx; v_U8_t *linePointer; numLines = dataSize / WLANTL_DEBUG_FRAME_BYTE_PER_LINE; numBytes = dataSize % WLANTL_DEBUG_FRAME_BYTE_PER_LINE; linePointer = (v_U8_t *)dataPointer; TLLOGE(VOS_TRACE(VOS_MODULE_ID_SAL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Frame Debug Frame Size %d, Pointer 0x%pK", dataSize, dataPointer)); for(idx = 0; idx < numLines; idx++) { memset(lineBuffer, 0, WLANTL_DEBUG_FRAME_BYTE_PER_LINE); memcpy(lineBuffer, linePointer, WLANTL_DEBUG_FRAME_BYTE_PER_LINE); TLLOGE(VOS_TRACE(VOS_MODULE_ID_SAL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x 0x%2x", lineBuffer[0], lineBuffer[1], lineBuffer[2], lineBuffer[3], lineBuffer[4], lineBuffer[5], lineBuffer[6], lineBuffer[7], lineBuffer[8], lineBuffer[9], lineBuffer[10], lineBuffer[11], lineBuffer[12], lineBuffer[13], lineBuffer[14], lineBuffer[15])); linePointer += WLANTL_DEBUG_FRAME_BYTE_PER_LINE; } if(0 == numBytes) return; memset(lineBuffer, 0, WLANTL_DEBUG_FRAME_BYTE_PER_LINE); memcpy(lineBuffer, linePointer, numBytes); for(idx = 0; idx < WLANTL_DEBUG_FRAME_BYTE_PER_LINE / WLANTL_DEBUG_FRAME_BYTE_PER_BYTE; idx++) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_SAL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:0x%2x 0x%2x 0x%2x 0x%2x", lineBuffer[idx * WLANTL_DEBUG_FRAME_BYTE_PER_BYTE], lineBuffer[1 + idx * WLANTL_DEBUG_FRAME_BYTE_PER_BYTE], lineBuffer[2 + idx * WLANTL_DEBUG_FRAME_BYTE_PER_BYTE], lineBuffer[3 + idx * WLANTL_DEBUG_FRAME_BYTE_PER_BYTE])); if(((idx + 1) * WLANTL_DEBUG_FRAME_BYTE_PER_BYTE) >= numBytes) break; } return; } #endif /*============================================================================= END LOG FUNCTION =============================================================================*/ /*========================================================================== FUNCTION WLANTL_Translate80211To8023Header DESCRIPTION Inline function for translating and 802.11 header into an 802.3 header. DEPENDENCIES PARAMETERS IN pTLCb: TL control block ucStaId: station ID ucHeaderLen: Length of the header from BD ucActualHLen: Length of header including padding or any other trailers IN/OUT vosDataBuff: vos data buffer, will contain the new header on output OUT pvosStatus: status of the operation RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_Translate80211To8023Header ( vos_pkt_t* vosDataBuff, VOS_STATUS* pvosStatus, v_U16_t usActualHLen, v_U8_t ucHeaderLen, WLANTL_CbType* pTLCb, v_U8_t ucSTAId, v_BOOL_t bForwardIAPPwithLLC ) { WLANTL_8023HeaderType w8023Header; WLANTL_80211HeaderType w80211Header; v_U8_t aucLLCHeader[WLANTL_LLC_HEADER_LEN]; VOS_STATUS vosStatus; v_U16_t usDataStartOffset = 0; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ if ( sizeof(w80211Header) < ucHeaderLen ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Warning !: Check the header size for the Rx frame structure=%d received=%dn", sizeof(w80211Header), ucHeaderLen)); ucHeaderLen = sizeof(w80211Header); } // This will take care of headers of all sizes, 3 address, 3 addr QOS, // WDS non-QOS and WDS QoS etc. We have space for all in the 802.11 header structure. vosStatus = vos_pkt_pop_head( vosDataBuff, &w80211Header, ucHeaderLen); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to pop 80211 header from packet %d", vosStatus)); return vosStatus; } switch ( w80211Header.wFrmCtrl.fromDS ) { case 0: if ( w80211Header.wFrmCtrl.toDS ) { //SoftAP AP mode vos_mem_copy( w8023Header.vDA, w80211Header.vA3, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL SoftAP: 802 3 DA %08x SA %08x", w8023Header.vDA, w8023Header.vSA)); } else { /* IBSS */ vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); } break; case 1: if ( w80211Header.wFrmCtrl.toDS ) { /* BT-AMP case */ vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); } else { /* Infra */ vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA3, VOS_MAC_ADDR_SIZE); } break; } if( usActualHLen > ucHeaderLen ) { usDataStartOffset = usActualHLen - ucHeaderLen; } if ( 0 < usDataStartOffset ) { vosStatus = vos_pkt_trim_head( vosDataBuff, usDataStartOffset ); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to trim header from packet %d", vosStatus)); return vosStatus; } } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if ( 0 != pTLCb->atlSTAClients[ucSTAId]->wSTADesc.ucAddRmvLLC #ifdef FEATURE_WLAN_ESE_UPLOAD && (!bForwardIAPPwithLLC) #endif /* FEATURE_WLAN_ESE_UPLOAD */ ) { // Extract the LLC header vosStatus = vos_pkt_pop_head( vosDataBuff, aucLLCHeader, WLANTL_LLC_HEADER_LEN); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL: Failed to pop LLC header from packet %d", vosStatus)); return vosStatus; } //Extract the length vos_mem_copy(&w8023Header.usLenType, &aucLLCHeader[WLANTL_LLC_HEADER_LEN - sizeof(w8023Header.usLenType)], sizeof(w8023Header.usLenType) ); } else { vosStatus = vos_pkt_get_packet_length(vosDataBuff, &w8023Header.usLenType); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to get packet length %d", vosStatus)); return vosStatus; } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: BTAMP len (ethertype) fld = %d", w8023Header.usLenType)); w8023Header.usLenType = vos_cpu_to_be16(w8023Header.usLenType); } vos_pkt_push_head(vosDataBuff, &w8023Header, sizeof(w8023Header)); #ifdef BTAMP_TEST { // AP side will execute this. v_U8_t *temp_w8023Header = NULL; vosStatus = vos_pkt_peek_data( vosDataBuff, 0, &temp_w8023Header, sizeof(w8023Header) ); } #endif #if 0 /*TL_DEBUG*/ vos_pkt_get_packet_length(vosDataBuff, &usLen); vos_pkt_pop_head( vosDataBuff, aucData, usLen); WLANTL_DebugFrame(aucData, usLen); vos_pkt_push_head(vosDataBuff, aucData, usLen); #endif *pvosStatus = VOS_STATUS_SUCCESS; return VOS_STATUS_SUCCESS; }/*WLANTL_Translate80211To8023Header*/ VOS_STATUS WLANTL_MonTranslate80211To8023Header ( vos_pkt_t* vosDataBuff, WLANTL_CbType* pTLCb ) { v_U16_t usMPDUDOffset; v_U8_t ucMPDUHOffset; v_U8_t ucMPDUHLen; v_U16_t usActualHLen = 0; v_U16_t usDataStartOffset = 0; v_PVOID_t aucBDHeader; WLANTL_8023HeaderType w8023Header; WLANTL_80211HeaderType w80211Header; VOS_STATUS vosStatus; v_U8_t aucLLCHeader[WLANTL_LLC_HEADER_LEN]; WDA_DS_PeekRxPacketInfo( vosDataBuff, (v_PVOID_t)&aucBDHeader, 0 ); ucMPDUHOffset = (v_U8_t)WDA_GET_RX_MPDU_HEADER_OFFSET(aucBDHeader); usMPDUDOffset = (v_U16_t)WDA_GET_RX_MPDU_DATA_OFFSET(aucBDHeader); ucMPDUHLen = (v_U8_t)WDA_GET_RX_MPDU_HEADER_LEN(aucBDHeader); if (usMPDUDOffset > ucMPDUHOffset) { usActualHLen = usMPDUDOffset - ucMPDUHOffset; } if ( sizeof(w80211Header) < ucMPDUHLen ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Warning !: Check the header size for the Rx frame structure=%d received=%dn", sizeof(w80211Header), ucMPDUHLen)); ucMPDUHLen = sizeof(w80211Header); } vosStatus = vos_pkt_pop_head( vosDataBuff, &w80211Header, ucMPDUHLen); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to pop 80211 header from packet %d", vosStatus)); return vosStatus; } switch ( w80211Header.wFrmCtrl.fromDS ) { case 0: if ( w80211Header.wFrmCtrl.toDS ) { vos_mem_copy( w8023Header.vDA, w80211Header.vA3, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL SoftAP: 802 3 DA %08x SA %08x", w8023Header.vDA, w8023Header.vSA)); } else { vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); } break; case 1: if ( w80211Header.wFrmCtrl.toDS ) { vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA2, VOS_MAC_ADDR_SIZE); } else { vos_mem_copy( w8023Header.vDA, w80211Header.vA1, VOS_MAC_ADDR_SIZE); vos_mem_copy( w8023Header.vSA, w80211Header.vA3, VOS_MAC_ADDR_SIZE); } break; } if( usActualHLen > ucMPDUHLen ) { usDataStartOffset = usActualHLen - ucMPDUHLen; } if ( 0 < usDataStartOffset ) { vosStatus = vos_pkt_trim_head( vosDataBuff, usDataStartOffset ); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to trim header from packet %d", vosStatus)); return vosStatus; } } // Extract the LLC header vosStatus = vos_pkt_pop_head( vosDataBuff, aucLLCHeader, WLANTL_LLC_HEADER_LEN); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "WLAN TL: Failed to pop LLC header from packet %d", vosStatus)); return vosStatus; } //Extract the length vos_mem_copy(&w8023Header.usLenType, &aucLLCHeader[WLANTL_LLC_HEADER_LEN - sizeof(w8023Header.usLenType)], sizeof(w8023Header.usLenType) ); vos_pkt_push_head(vosDataBuff, &w8023Header, sizeof(w8023Header)); return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION WLANTL_FindFrameTypeBcMcUc DESCRIPTION Utility function to find whether received frame is broadcast, multicast or unicast. DEPENDENCIES The STA must be registered with TL before this function can be called. PARAMETERS IN pTLCb: pointer to the TL's control block ucSTAId: identifier of the station being processed vosDataBuff: pointer to the vos buffer IN/OUT pucBcMcUc: pointer to buffer, will contain frame type on return RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_E_BADMSG: failed to extract info from data buffer VOS_STATUS_SUCCESS: success SIDE EFFECTS None. ============================================================================*/ VOS_STATUS WLANTL_FindFrameTypeBcMcUc ( WLANTL_CbType *pTLCb, v_U8_t ucSTAId, vos_pkt_t *vosDataBuff, v_U8_t *pucBcMcUc ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; v_PVOID_t aucBDHeader; v_PVOID_t pvPeekData; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ((NULL == pTLCb) || (NULL == vosDataBuff) || (NULL == pucBcMcUc)) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter in WLANTL_FindFrameTypeBcMcUc")); return VOS_STATUS_E_INVAL; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*------------------------------------------------------------------------ Extract BD header and check if valid ------------------------------------------------------------------------*/ vosStatus = WDA_DS_PeekRxPacketInfo(vosDataBuff, (v_PVOID_t)&aucBDHeader, 0/*Swap BD*/ ); if (NULL == aucBDHeader) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:WLANTL_FindFrameTypeBcMcUc - Cannot extract BD header")); VOS_ASSERT(0); return VOS_STATUS_E_BADMSG; } if ((0 == WDA_GET_RX_FT_DONE(aucBDHeader)) && (0 != pTLCb->atlSTAClients[ucSTAId]->wSTADesc.ucSwFrameRXXlation)) { /* Its an 802.11 frame, extract MAC address 1 */ TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_FindFrameTypeBcMcUc - 802.11 frame, peeking Addr1")); vosStatus = vos_pkt_peek_data(vosDataBuff, WLANTL_MAC_ADDR_ALIGN(1), (v_PVOID_t)&pvPeekData, VOS_MAC_ADDR_SIZE); } else { /* Its an 802.3 frame, extract Destination MAC address */ TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_FindFrameTypeBcMcUc - 802.3 frame, peeking DA")); vosStatus = vos_pkt_peek_data(vosDataBuff, WLANTL_MAC_ADDR_ALIGN(0), (v_PVOID_t)&pvPeekData, VOS_MAC_ADDR_SIZE); } if (VOS_STATUS_SUCCESS != vosStatus) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:WLANTL_FindFrameTypeBcMcUc - Failed to peek MAC address")); return vosStatus; } if (((tANI_U8 *)pvPeekData)[0] == 0xff) { *pucBcMcUc = WLANTL_FRAME_TYPE_BCAST; } else { if ((((tANI_U8 *)pvPeekData)[0] & 0x01) == 0x01) *pucBcMcUc = WLANTL_FRAME_TYPE_MCAST; else *pucBcMcUc = WLANTL_FRAME_TYPE_UCAST; } TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:WLANTL_FindFrameTypeBcMcUc - Addr1Byte1 is: %x", ((tANI_U8 *)pvPeekData)[0])); return VOS_STATUS_SUCCESS; } #if 0 #ifdef WLAN_PERF /*========================================================================== FUNCTION WLANTL_FastHwFwdDataFrame DESCRIPTION Fast path function to quickly forward a data frame if HAL determines BD signature computed here matches the signature inside current VOSS packet. If there is a match, HAL and TL fills in the swapped packet length into BD header and DxE header, respectively. Otherwise, packet goes back to normal (slow) path and a new BD signature would be tagged into BD in this VOSS packet later by the WLANHAL_FillTxBd() function. DEPENDENCIES PARAMETERS IN pvosGCtx VOS context vosDataBuff Ptr to VOSS packet pMetaInfo For getting frame's TID pStaInfo For checking STA type OUT pvosStatus returned status puFastFwdOK Flag to indicate whether frame could be fast forwarded RETURN VALUE No return. SIDE EFFECTS ============================================================================*/ static void WLANTL_FastHwFwdDataFrame ( v_PVOID_t pvosGCtx, vos_pkt_t* vosDataBuff, VOS_STATUS* pvosStatus, v_U32_t* puFastFwdOK, WLANTL_MetaInfoType* pMetaInfo, WLAN_STADescType* pStaInfo ) { v_PVOID_t pvPeekData; v_U8_t ucDxEBDWLANHeaderLen = WLANTL_BD_HEADER_LEN(0) + sizeof(WLANBAL_sDXEHeaderType); v_U8_t ucIsUnicast; WLANBAL_sDXEHeaderType *pDxEHeader; v_PVOID_t pvBDHeader; v_PVOID_t pucBuffPtr; v_U16_t usPktLen; /*----------------------------------------------------------------------- Extract packet length -----------------------------------------------------------------------*/ vos_pkt_get_packet_length( vosDataBuff, &usPktLen); /*----------------------------------------------------------------------- Extract MAC address -----------------------------------------------------------------------*/ *pvosStatus = vos_pkt_peek_data( vosDataBuff, WLANTL_MAC_ADDR_ALIGN(0), (v_PVOID_t)&pvPeekData, VOS_MAC_ADDR_SIZE ); if ( VOS_STATUS_SUCCESS != *pvosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while attempting to extract MAC Addr %d", *pvosStatus)); *pvosStatus = VOS_STATUS_E_INVAL; return; } /*----------------------------------------------------------------------- Reserve head room for DxE header, BD, and WLAN header -----------------------------------------------------------------------*/ vos_pkt_reserve_head( vosDataBuff, &pucBuffPtr, ucDxEBDWLANHeaderLen ); if ( NULL == pucBuffPtr ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:No enough space in VOSS packet %pK for DxE/BD/WLAN header", vosDataBuff)); *pvosStatus = VOS_STATUS_E_INVAL; return; } pDxEHeader = (WLANBAL_sDXEHeaderType *)pucBuffPtr; pvBDHeader = (v_PVOID_t) &pDxEHeader[1]; /* UMA Tx acceleration is enabled. * UMA would help convert frames to 802.11, fill partial BD fields and * construct LLC header. To further accelerate this kind of frames, * HAL would attempt to reuse the BD descriptor if the BD signature * matches to the saved BD descriptor. */ if(pStaInfo->wSTAType == WLAN_STA_IBSS) ucIsUnicast = !(((tANI_U8 *)pvPeekData)[0] & 0x01); else ucIsUnicast = 1; *puFastFwdOK = (v_U32_t) WLANHAL_TxBdFastFwd(pvosGCtx, pvPeekData, pMetaInfo->ucTID, ucIsUnicast, pvBDHeader, usPktLen ); /* Can't be fast forwarded. Trim the VOS head back to original location. */ if(! *puFastFwdOK){ vos_pkt_trim_head(vosDataBuff, ucDxEBDWLANHeaderLen); }else{ /* could be fast forwarded. Now notify BAL DxE header filling could be completely skipped */ v_U32_t uPacketSize = WLANTL_BD_HEADER_LEN(0) + usPktLen; vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_BAL, (v_PVOID_t)uPacketSize); pDxEHeader->size = SWAP_ENDIAN_UINT32(uPacketSize); } *pvosStatus = VOS_STATUS_SUCCESS; return; } #endif /*WLAN_PERF*/ #endif #if 0 /*========================================================================== FUNCTION WLANTL_PrepareBDHeader DESCRIPTION Inline function for preparing BD header before HAL processing. DEPENDENCIES Just notify HAL that suspend in TL is complete. PARAMETERS IN vosDataBuff: vos data buffer ucDisableFrmXtl: is frame xtl disabled OUT ppvBDHeader: it will contain the BD header pvDestMacAdddr: it will contain the destination MAC address pvosStatus: status of the combined processing pusPktLen: packet len. RETURN VALUE No return. SIDE EFFECTS ============================================================================*/ void WLANTL_PrepareBDHeader ( vos_pkt_t* vosDataBuff, v_PVOID_t* ppvBDHeader, v_MACADDR_t* pvDestMacAdddr, v_U8_t ucDisableFrmXtl, VOS_STATUS* pvosStatus, v_U16_t* pusPktLen, v_U8_t ucQosEnabled, v_U8_t ucWDSEnabled, v_U8_t extraHeadSpace ) { v_U8_t ucHeaderOffset; v_U8_t ucHeaderLen; v_U8_t ucBDHeaderLen = WLANTL_BD_HEADER_LEN(ucDisableFrmXtl); /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------- Get header pointer from VOSS !!! make sure reserve head zeros out the memory -------------------------------------------------------------------------*/ vos_pkt_get_packet_length( vosDataBuff, pusPktLen); if ( WLANTL_MAC_HEADER_LEN(ucDisableFrmXtl) > *pusPktLen ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Length of the packet smaller than expected network" " header %d", *pusPktLen )); *pvosStatus = VOS_STATUS_E_INVAL; return; } vos_pkt_reserve_head( vosDataBuff, ppvBDHeader, ucBDHeaderLen ); if ( NULL == *ppvBDHeader ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:VOSS packet corrupted on Attach BD header")); *pvosStatus = VOS_STATUS_E_INVAL; return; } /*----------------------------------------------------------------------- Extract MAC address -----------------------------------------------------------------------*/ { v_SIZE_t usMacAddrSize = VOS_MAC_ADDR_SIZE; *pvosStatus = vos_pkt_extract_data( vosDataBuff, ucBDHeaderLen + WLANTL_MAC_ADDR_ALIGN(ucDisableFrmXtl), (v_PVOID_t)pvDestMacAdddr, &usMacAddrSize ); } if ( VOS_STATUS_SUCCESS != *pvosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed while attempting to extract MAC Addr %d", *pvosStatus)); } else { /*--------------------------------------------------------------------- Fill MPDU info fields: - MPDU data start offset - MPDU header start offset - MPDU header length - MPDU length - this is a 16b field - needs swapping --------------------------------------------------------------------*/ ucHeaderOffset = ucBDHeaderLen; ucHeaderLen = WLANTL_MAC_HEADER_LEN(ucDisableFrmXtl); if ( 0 != ucDisableFrmXtl ) { if ( 0 != ucQosEnabled ) { ucHeaderLen += WLANTL_802_11_HEADER_QOS_CTL; } // Similar to Qos we need something for WDS format ! if ( ucWDSEnabled != 0 ) { // If we have frame translation enabled ucHeaderLen += WLANTL_802_11_HEADER_ADDR4_LEN; } if ( extraHeadSpace != 0 ) { // Decrease the packet length with the extra padding after the header *pusPktLen = *pusPktLen - extraHeadSpace; } } WLANHAL_TX_BD_SET_MPDU_HEADER_LEN( *ppvBDHeader, ucHeaderLen); WLANHAL_TX_BD_SET_MPDU_HEADER_OFFSET( *ppvBDHeader, ucHeaderOffset); WLANHAL_TX_BD_SET_MPDU_DATA_OFFSET( *ppvBDHeader, ucHeaderOffset + ucHeaderLen + extraHeadSpace); WLANHAL_TX_BD_SET_MPDU_LEN( *ppvBDHeader, *pusPktLen); TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: VALUES ARE HLen=%x Hoff=%x doff=%x len=%x ex=%d", ucHeaderLen, ucHeaderOffset, (ucHeaderOffset + ucHeaderLen + extraHeadSpace), *pusPktLen, extraHeadSpace)); }/* if peek MAC success*/ }/* WLANTL_PrepareBDHeader */ #endif //THIS IS A HACK AND NEEDS TO BE FIXED FOR CONCURRENCY /*========================================================================== FUNCTION WLAN_TLGetNextTxIds DESCRIPTION Gets the next station and next AC in the list that should be served by the TL. Multiple Station Scheduling and TL queue management. 4 HDD BC/MC data packet queue status is specified as Station 0's status. Weights used in WFQ algorith are initialized in WLANTL_OPEN and contained in tlConfigInfo field. Each station has fields of ucPktPending and AC mask to tell whether a AC has traffic or not. Stations are served in a round-robin fashion from highest priority to lowest priority. The number of round-robin times of each prioirty equals to the WFQ weights and differetiates the traffic of different prioirty. As such, stations can not provide low priority packets if high priority packets are all served. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context OUT pucSTAId: Station ID RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good SIDE EFFECTS TL context contains currently served station ID in ucCurrentSTA field, currently served AC in uCurServedAC field, and unserved weights of current AC in uCurLeftWeight. When existing from the function, these three fields are changed accordingly. ============================================================================*/ VOS_STATUS WLAN_TLAPGetNextTxIds ( v_PVOID_t pvosGCtx, v_U8_t* pucSTAId ) { WLANTL_CbType* pTLCb; v_U8_t ucACFilter = 1; v_U8_t ucNextSTA, ucTempSTA; v_BOOL_t isServed = TRUE; //current round has find a packet or not v_U8_t ucACLoopNum = WLANTL_AC_HIGH_PRIO + 1; //number of loop to go v_U8_t uFlowMask; // TX FlowMask from WDA uint8 ucACMask; uint8 i = 0; uint8 j; uint8 minWeightSta; uint32_t sta_bitmask = 0; /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ //ENTER(); pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLAN_TLAPGetNextTxIds")); return VOS_STATUS_E_FAULT; } if ( VOS_STATUS_SUCCESS != WDA_DS_GetTxFlowMask( pvosGCtx, &uFlowMask ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed to retrieve Flow control mask from WDA")); return VOS_STATUS_E_FAULT; } /* The flow mask does not differentiate between different ACs/Qs * since we use a single dxe channel for all ACs/Qs, hence it is * enough to check that there are dxe resources on data channel */ uFlowMask &= WLANTL_DATA_FLOW_MASK; if (0 == uFlowMask) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: No resources to send packets")); // Setting STA Id to invalid if mask is 0 *pucSTAId = WLAN_MAX_STA_COUNT; return VOS_STATUS_E_FAULT; } ucNextSTA = pTLCb->ucCurrentSTA; ++ucNextSTA; if ( WLAN_MAX_STA_COUNT <= ucNextSTA ) ucNextSTA = 0; isServed = FALSE; if ( 0 == pTLCb->ucCurLeftWeight ) { //current prioirty is done if ( WLANTL_AC_BK == (WLANTL_ACEnumType)pTLCb->uCurServedAC ) { //end of current VO, VI, BE, BK loop. Reset priority. pTLCb->uCurServedAC = WLANTL_AC_HIGH_PRIO; } else { pTLCb->uCurServedAC --; } pTLCb->ucCurLeftWeight = pTLCb->tlConfigInfo.ucAcWeights[pTLCb->uCurServedAC]; } // (0 == pTLCb->ucCurLeftWeight) ucTempSTA = ucNextSTA; minWeightSta = ucNextSTA; //decide how many loops to go. if current loop is partial, do one extra to make sure //we cover every station if ((1 == pTLCb->ucCurLeftWeight) && (ucNextSTA != 0)) { ucACLoopNum ++; // now is 5 loops } /* Start with highest priority. ucNextSTA, pTLCb->uCurServedAC, pTLCb->ucCurLeftWeight all have previous values.*/ for (; ucACLoopNum > 0; ucACLoopNum--) { ucACFilter = 1 << pTLCb->uCurServedAC; // pTLCb->ucCurLeftWeight keeps previous results. for (; (pTLCb->ucCurLeftWeight > 0) ; pTLCb->ucCurLeftWeight-- ) { for ( ; ucNextSTA < WLAN_MAX_STA_COUNT; ucNextSTA ++ ) { if(NULL == pTLCb->atlSTAClients[ucNextSTA]) { continue; } WLAN_TL_AC_ARRAY_2_MASK (pTLCb->atlSTAClients[ucNextSTA], ucACMask, i); if ( (0 == pTLCb->atlSTAClients[ucNextSTA]->ucExists) || ((0 == pTLCb->atlSTAClients[ucNextSTA]->ucPktPending) && !(ucACMask)) || (0 == (ucACMask & ucACFilter)) ) { //current station does not exist or have any packet to serve. continue; } if ((WLANTL_STA_AUTHENTICATED != pTLCb->atlSTAClients[ucNextSTA]->tlState) || (pTLCb->atlSTAClients[ucNextSTA]->disassoc_progress == VOS_TRUE )) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s Sta %d not in auth state so skipping it.", __func__, ucNextSTA)); continue; } //go to next station if current station can't send due to flow control //Station is allowed to send when it is not in LWM mode. When station is in LWM mode, //station is allowed to send only after FW reports FW memory is below threshold and on-fly //packets are less then allowed value if ( (TRUE == pTLCb->atlSTAClients[ucNextSTA]->ucLwmModeEnabled) && ((FALSE == pTLCb->atlSTAClients[ucNextSTA]->ucLwmEventReported) || (0 < pTLCb->atlSTAClients[ucNextSTA]->uBuffThresholdMax)) ) { continue; } /* * Initial weight is 0 is for all the stations. As part of FW TX stats * indication to host, good peer weight is updated to one and the * remaining peers weight is updated based on their RA rates and BTQM * queued frames length. TL skips fetching the packet until the station * has got chances equal to its weight. */ if (pTLCb->atlSTAClients[ucNextSTA]->weight > WLANTL_GOOD_STA_WEIGHT) { if (pTLCb->atlSTAClients[ucNextSTA]->weight_count <= pTLCb->atlSTAClients[ucNextSTA]->weight) { if (pTLCb->atlSTAClients[minWeightSta]->weight <= 1) minWeightSta = ucNextSTA; else if (pTLCb->atlSTAClients[ucNextSTA]->weight < pTLCb->atlSTAClients[minWeightSta]->weight) { minWeightSta = ucNextSTA; } sta_bitmask |= (1 << ucNextSTA); pTLCb->atlSTAClients[ucNextSTA]->weight_count++; continue; } else pTLCb->atlSTAClients[ucNextSTA]->weight_count = 0; } // Find a station. Weight is updated already. *pucSTAId = ucNextSTA; pTLCb->ucCurrentSTA = ucNextSTA; pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = pTLCb->uCurServedAC; TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, " TL serve one station AC: %d W: %d StaId: %d", pTLCb->uCurServedAC, pTLCb->ucCurLeftWeight, pTLCb->ucCurrentSTA )); pTLCb->ucCurLeftWeight--; return VOS_STATUS_SUCCESS; } //STA loop for (j = 0; j < ucTempSTA; j++) { if (NULL == pTLCb->atlSTAClients[j]) continue; WLAN_TL_AC_ARRAY_2_MASK (pTLCb->atlSTAClients[j], ucACMask, i); if ((0 == pTLCb->atlSTAClients[j]->ucExists) || ((0 == pTLCb->atlSTAClients[j]->ucPktPending) && !(ucACMask)) || (0 == (ucACMask & ucACFilter))) continue; if ((WLANTL_STA_AUTHENTICATED != pTLCb->atlSTAClients[j]->tlState) || (pTLCb->atlSTAClients[j]->disassoc_progress == VOS_TRUE)) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s Sta %d not in auth state so skipping it.", __func__, ucNextSTA)); continue; } if ((TRUE == pTLCb->atlSTAClients[j]->ucLwmModeEnabled) && ((FALSE == pTLCb->atlSTAClients[j]->ucLwmEventReported) || (0 < pTLCb->atlSTAClients[j]->uBuffThresholdMax))) continue; if (pTLCb->atlSTAClients[j]->weight > WLANTL_GOOD_STA_WEIGHT) { if (pTLCb->atlSTAClients[j]->weight_count <= pTLCb->atlSTAClients[j]->weight) { if (pTLCb->atlSTAClients[minWeightSta]->weight <= 1) minWeightSta = j; else if (pTLCb->atlSTAClients[j]->weight < pTLCb->atlSTAClients[minWeightSta]->weight) { minWeightSta = j; } sta_bitmask |= (1 << j); pTLCb->atlSTAClients[j]->weight_count++; continue; } else pTLCb->atlSTAClients[j]->weight_count = 0; } *pucSTAId = j; pTLCb->ucCurrentSTA = j; pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = pTLCb->uCurServedAC; TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, " TL serve one station AC: %d W: %d StaId: %d", pTLCb->uCurServedAC, pTLCb->ucCurLeftWeight, pTLCb->ucCurrentSTA )); pTLCb->ucCurLeftWeight--; return VOS_STATUS_SUCCESS; } /* Fecth packet from the stations with minimum weight among them */ if (pTLCb->atlSTAClients[minWeightSta] && pTLCb->atlSTAClients[minWeightSta]->ucPktPending) { *pucSTAId = minWeightSta; pTLCb->ucCurrentSTA = minWeightSta; pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = pTLCb->uCurServedAC; for (j = 0; sta_bitmask != 0; sta_bitmask >>= 1, j++) { if (0 == (sta_bitmask & 0x1)) continue; if (minWeightSta == j) continue; /* To ensure fairness between stations */ pTLCb->atlSTAClients[j]->weight_count += pTLCb->atlSTAClients[minWeightSta]->weight - pTLCb->atlSTAClients[minWeightSta]->weight_count; } pTLCb->atlSTAClients[minWeightSta]->weight_count = 0; TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW, " TL serve one station AC: %d W: %d StaId: %d", pTLCb->uCurServedAC, pTLCb->ucCurLeftWeight, pTLCb->ucCurrentSTA )); pTLCb->ucCurLeftWeight--; return VOS_STATUS_SUCCESS; } ucNextSTA = 0; if ( FALSE == isServed ) { //current loop finds no packet.no need to repeat for the same priority break; } //current loop is partial loop. go for one more loop. isServed = FALSE; } //Weight loop if (WLANTL_AC_BK == pTLCb->uCurServedAC) { pTLCb->uCurServedAC = WLANTL_AC_HIGH_PRIO; } else { pTLCb->uCurServedAC--; } pTLCb->ucCurLeftWeight = pTLCb->tlConfigInfo.ucAcWeights[pTLCb->uCurServedAC]; }// AC loop TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, " TL can't find one station to serve" )); pTLCb->uCurServedAC = WLANTL_AC_BK; pTLCb->ucCurLeftWeight = 1; //invalid number will be captured by caller pTLCb->ucCurrentSTA = WLAN_MAX_STA_COUNT; *pucSTAId = pTLCb->ucCurrentSTA; return VOS_STATUS_E_FAULT; } /*========================================================================== FUNCTION WLAN_TLGetNextTxIds DESCRIPTION Gets the next station and next AC in the list DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context OUT pucSTAId: Station ID RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLAN_TLGetNextTxIds ( v_PVOID_t pvosGCtx, v_U8_t* pucSTAId ) { WLANTL_CbType* pTLCb; v_U8_t ucNextAC; v_U8_t ucNextSTA; v_U8_t ucCount; v_U8_t uFlowMask; // TX FlowMask from WDA v_U8_t ucACMask = 0; v_U8_t i = 0; tBssSystemRole systemRole; //RG HACK to be removed tpAniSirGlobal pMac; pMac = vos_get_context(VOS_MODULE_ID_PE, pvosGCtx); if ( NULL == pMac ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid pMac", __func__)); return VOS_STATUS_E_FAULT; } systemRole = wdaGetGlobalSystemRole(pMac); /*------------------------------------------------------------------------ Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLAN_TLGetNextTxIds")); return VOS_STATUS_E_FAULT; } #ifdef FEATURE_WLAN_TDLS if ((eSYSTEM_AP_ROLE == systemRole) || (eSYSTEM_STA_IN_IBSS_ROLE == systemRole) || (vos_concurrent_open_sessions_running()) || pTLCb->ucTdlsPeerCount) #else if ((eSYSTEM_AP_ROLE == systemRole) || (eSYSTEM_STA_IN_IBSS_ROLE == systemRole) || (vos_concurrent_open_sessions_running())) #endif { return WLAN_TLAPGetNextTxIds(pvosGCtx,pucSTAId); } if ( VOS_STATUS_SUCCESS != WDA_DS_GetTxFlowMask( pvosGCtx, &uFlowMask ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Failed to retrieve Flow control mask from WDA")); return VOS_STATUS_E_FAULT; } /* The flow mask does not differentiate between different ACs/Qs * since we use a single dxe channel for all ACs/Qs, hence it is * enough to check that there are dxe resources on data channel */ uFlowMask &= WLANTL_DATA_FLOW_MASK; if (0 == uFlowMask) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: No resources to send packets")); // Setting STA id to invalid if mask is 0 *pucSTAId = WLAN_MAX_STA_COUNT; return VOS_STATUS_E_FAULT; } /*STA id - no priority yet implemented */ /*----------------------------------------------------------------------- Choose the next STA for tx - for now go in a round robin fashion through all the stations that have pending packets -------------------------------------------------------------------------*/ ucNextSTA = pTLCb->ucCurrentSTA; pTLCb->ucCurrentSTA = WLAN_MAX_STA_COUNT; for ( ucCount = 0; ucCount < WLAN_MAX_STA_COUNT; ucCount++ ) { ucNextSTA = ( (ucNextSTA+1) >= WLAN_MAX_STA_COUNT )?0:(ucNextSTA+1); if(NULL == pTLCb->atlSTAClients[ucNextSTA]) { continue; } if ((pTLCb->atlSTAClients[ucNextSTA]->weight > WLANTL_GOOD_STA_WEIGHT) && (pTLCb->atlSTAClients[ucNextSTA]->ucPktPending)) { if (pTLCb->atlSTAClients[ucNextSTA]->weight_count <= pTLCb->atlSTAClients[ucNextSTA]->weight) { pTLCb->atlSTAClients[ucNextSTA]->weight_count++; continue; } else pTLCb->atlSTAClients[ucNextSTA]->weight_count = 0; } if (( pTLCb->atlSTAClients[ucNextSTA]->ucExists ) && ( pTLCb->atlSTAClients[ucNextSTA]->ucPktPending )) { if (WLANTL_STA_AUTHENTICATED == pTLCb->atlSTAClients[ucNextSTA]->tlState) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "STA ID: %d on WLAN_TLGetNextTxIds", *pucSTAId)); pTLCb->ucCurrentSTA = ucNextSTA; break; } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s Sta %d is not in auth state, skipping this sta.", __func__, ucNextSTA)); } } } *pucSTAId = pTLCb->ucCurrentSTA; if ( WLANTL_STA_ID_INVALID( *pucSTAId ) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:No station registered with TL at this point")); return VOS_STATUS_E_FAULT; } /*Convert the array to a mask for easier operation*/ WLAN_TL_AC_ARRAY_2_MASK( pTLCb->atlSTAClients[*pucSTAId], ucACMask, i); if ( 0 == ucACMask ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Mask 0 " "STA ID: %d on WLAN_TLGetNextTxIds", *pucSTAId)); /*setting STA id to invalid if mask is 0*/ *pucSTAId = WLAN_MAX_STA_COUNT; return VOS_STATUS_E_FAULT; } /*----------------------------------------------------------------------- AC is updated whenever a packet is fetched from HDD -> the current weight of such an AC cannot be 0 -> in this case TL is expected to exit this function at this point during the main Tx loop -----------------------------------------------------------------------*/ if ( 0 < pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Maintaining serviced AC to: %d for Weight: %d", pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC , pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight)); return VOS_STATUS_SUCCESS; } /*----------------------------------------------------------------------- Choose highest priority AC - !!! optimize me -----------------------------------------------------------------------*/ ucNextAC = pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Next AC: %d", ucNextAC)); while ( 0 != ucACMask ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, " AC Mask: %d Next: %d Res : %d", ucACMask, ( 1 << ucNextAC ), ( ucACMask & ( 1 << ucNextAC )))); if ( 0 != ( ucACMask & ( 1 << ucNextAC ))) { pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = (WLANTL_ACEnumType)ucNextAC; pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight = pTLCb->tlConfigInfo.ucAcWeights[ucNextAC]; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Switching serviced AC to: %d with Weight: %d", pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC , pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight)); break; } if (ucNextAC == WLANTL_AC_BK) ucNextAC = WLANTL_AC_HIGH_PRIO; else ucNextAC--; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "Next AC %d", ucNextAC)); } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, " C AC: %d C W: %d", pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC, pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight)); return VOS_STATUS_SUCCESS; }/* WLAN_TLGetNextTxIds */ /*========================================================================== DEFAULT HANDLERS: Registered at initialization with TL ==========================================================================*/ /*========================================================================== FUNCTION WLANTL_MgmtFrmRxDefaultCb DESCRIPTION Default Mgmt Frm rx callback: asserts all the time. If this function gets called it means there is no registered rx cb pointer for Mgmt Frm. DEPENDENCIES PARAMETERS Not used. RETURN VALUE VOS_STATUS_E_FAILURE: Always FAILURE. ============================================================================*/ VOS_STATUS WLANTL_MgmtFrmRxDefaultCb ( v_PVOID_t pvosGCtx, v_PVOID_t vosBuff ) { if ( NULL != vosBuff ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Fatal failure: No registered Mgmt Frm client on pkt RX")); /* Drop packet */ vos_pkt_return_packet((vos_pkt_t *)vosBuff); } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: No registered Mgmt Frm client on pkt RX. Load/Unload in progress, Ignore")); return VOS_STATUS_E_FAILURE; }/*WLANTL_MgmtFrmRxDefaultCb*/ /*========================================================================== FUNCTION WLANTL_BAPRxDefaultCb DESCRIPTION Default BAP rx callback: asserts all the time. If this function gets called it means there is no registered rx cb pointer for BAP. DEPENDENCIES PARAMETERS Not used. RETURN VALUE VOS_STATUS_E_FAILURE: Always FAILURE. ============================================================================*/ VOS_STATUS WLANTL_BAPRxDefaultCb ( v_PVOID_t pvosGCtx, vos_pkt_t* vosDataBuff, WLANTL_BAPFrameEnumType frameType ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Fatal failure: No registered BAP client on BAP pkt RX")); #ifndef BTAMP_TEST VOS_ASSERT(0); #endif return VOS_STATUS_E_FAILURE; }/*WLANTL_MgmtFrmRxDefaultCb*/ /*========================================================================== FUNCTION WLANTL_STARxDefaultCb DESCRIPTION Default STA rx callback: asserts all the time. If this function gets called it means there is no registered rx cb pointer for station. (Mem corruption most likely, it should never happen) DEPENDENCIES PARAMETERS Not used. RETURN VALUE VOS_STATUS_E_FAILURE: Always FAILURE. ============================================================================*/ VOS_STATUS WLANTL_STARxDefaultCb ( v_PVOID_t pvosGCtx, vos_pkt_t* vosDataBuff, v_U8_t ucSTAId, WLANTL_RxMetaInfoType* pRxMetaInfo ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: No registered STA client rx cb for STAID: %d dropping pkt", ucSTAId)); vos_pkt_return_packet(vosDataBuff); return VOS_STATUS_SUCCESS; }/*WLANTL_MgmtFrmRxDefaultCb*/ /*========================================================================== FUNCTION WLANTL_STAFetchPktDefaultCb DESCRIPTION Default fetch callback: asserts all the time. If this function gets called it means there is no registered fetch cb pointer for station. (Mem corruption most likely, it should never happen) DEPENDENCIES PARAMETERS Not used. RETURN VALUE VOS_STATUS_E_FAILURE: Always FAILURE. ============================================================================*/ VOS_STATUS WLANTL_STAFetchPktDefaultCb ( v_PVOID_t pvosGCtx, v_U8_t* pucSTAId, WLANTL_ACEnumType ucAC, vos_pkt_t** vosDataBuff, WLANTL_MetaInfoType* tlMetaInfo ) { TLLOGP(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Fatal failure: No registered STA client on data pkt RX")); VOS_ASSERT(0); return VOS_STATUS_E_FAILURE; }/*WLANTL_MgmtFrmRxDefaultCb*/ /*========================================================================== FUNCTION WLANTL_TxCompDefaultCb DESCRIPTION Default tx complete handler. It will release the completed pkt to prevent memory leaks. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL/HAL/PE/BAP/HDD control block can be extracted from its context vosDataBuff: pointer to the VOSS data buffer that was transmitted wTxSTAtus: status of the transmission RETURN VALUE The result code associated with performing the operation; please check vos_pkt_return_packet for possible error codes. Please check vos_pkt_return_packet API for possible return values. ============================================================================*/ VOS_STATUS WLANTL_TxCompDefaultCb ( v_PVOID_t pvosGCtx, vos_pkt_t* vosDataBuff, VOS_STATUS wTxSTAtus ) { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:TXComp not registered, releasing pkt to prevent mem leak")); return vos_pkt_return_packet(vosDataBuff); }/*WLANTL_TxCompDefaultCb*/ /*========================================================================== Cleanup functions ==========================================================================*/ /*========================================================================== FUNCTION WLANTL_CleanCB DESCRIPTION Cleans TL control block DEPENDENCIES PARAMETERS IN pTLCb: pointer to TL's control block ucEmpty: set if TL has to clean up the queues and release pedning pkts RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_CleanCB ( WLANTL_CbType* pTLCb, v_U8_t ucEmpty ) { v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------- Sanity check -------------------------------------------------------------------------*/ if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_CleanCB")); return VOS_STATUS_E_INVAL; } /* number of packets sent to BAL waiting for tx complete confirmation */ pTLCb->usPendingTxCompleteCount = 0; /* global suspend flag */ vos_atomic_set_U8( &pTLCb->ucTxSuspended, 1); /* resource flag */ pTLCb->uResCount = 0; /*------------------------------------------------------------------------- Client stations -------------------------------------------------------------------------*/ for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT ; ucIndex++) { if(NULL != pTLCb->atlSTAClients[ucIndex]) { WLANTL_CleanSTA( pTLCb->atlSTAClients[ucIndex], ucEmpty); } } /*------------------------------------------------------------------------- Management Frame client -------------------------------------------------------------------------*/ pTLCb->tlMgmtFrmClient.ucExists = 0; if ( ( 0 != ucEmpty) && ( NULL != pTLCb->tlMgmtFrmClient.vosPendingDataBuff )) { vos_pkt_return_packet(pTLCb->tlMgmtFrmClient.vosPendingDataBuff); } pTLCb->tlMgmtFrmClient.vosPendingDataBuff = NULL; /* set to a default cb in order to prevent constant checking for NULL */ pTLCb->tlMgmtFrmClient.pfnTlMgmtFrmRx = WLANTL_MgmtFrmRxDefaultCb; /*------------------------------------------------------------------------- BT AMP client -------------------------------------------------------------------------*/ pTLCb->tlBAPClient.ucExists = 0; if (( 0 != ucEmpty) && ( NULL != pTLCb->tlBAPClient.vosPendingDataBuff )) { vos_pkt_return_packet(pTLCb->tlBAPClient.vosPendingDataBuff); } if (( 0 != ucEmpty) && ( NULL != pTLCb->vosDummyBuf )) { vos_pkt_return_packet(pTLCb->vosDummyBuf); } pTLCb->tlBAPClient.vosPendingDataBuff = NULL; pTLCb->vosDummyBuf = NULL; pTLCb->vosTempBuf = NULL; pTLCb->ucCachedSTAId = WLAN_MAX_STA_COUNT; /* set to a default cb in order to prevent constant checking for NULL */ pTLCb->tlBAPClient.pfnTlBAPRx = WLANTL_BAPRxDefaultCb; pTLCb->ucRegisteredStaId = WLAN_MAX_STA_COUNT; return VOS_STATUS_SUCCESS; }/* WLANTL_CleanCB*/ /*========================================================================== FUNCTION WLANTL_CleanSTA DESCRIPTION Cleans a station control block. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucEmpty: if set the queues and pending pkts will be emptyed RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: invalid input parameters VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_CleanSTA ( WLANTL_STAClientType* ptlSTAClient, v_U8_t ucEmpty ) { v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------- Sanity check -------------------------------------------------------------------------*/ if ( NULL == ptlSTAClient ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_CleanSTA")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Clear station from TL ------------------------------------------------------------------------*/ TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: Clearing STA Client ID: %d, Empty flag: %d", ptlSTAClient->wSTADesc.ucSTAId, ucEmpty )); ptlSTAClient->pfnSTARx = WLANTL_STARxDefaultCb; ptlSTAClient->pfnSTATxComp = WLANTL_TxCompDefaultCb; ptlSTAClient->pfnSTAFetchPkt = WLANTL_STAFetchPktDefaultCb; ptlSTAClient->tlState = WLANTL_STA_INIT; ptlSTAClient->tlPri = WLANTL_STA_PRI_NORMAL; vos_zero_macaddr( &ptlSTAClient->wSTADesc.vSTAMACAddress ); vos_zero_macaddr( &ptlSTAClient->wSTADesc.vBSSIDforIBSS ); vos_zero_macaddr( &ptlSTAClient->wSTADesc.vSelfMACAddress ); ptlSTAClient->wSTADesc.ucSTAId = 0; ptlSTAClient->wSTADesc.wSTAType = WLAN_STA_MAX; ptlSTAClient->wSTADesc.ucQosEnabled = 0; ptlSTAClient->wSTADesc.ucAddRmvLLC = 0; ptlSTAClient->wSTADesc.ucSwFrameTXXlation = 0; ptlSTAClient->wSTADesc.ucSwFrameRXXlation = 0; ptlSTAClient->wSTADesc.ucProtectedFrame = 0; ptlSTAClient->disassoc_progress = VOS_FALSE; /*------------------------------------------------------------------------- AMSDU information for the STA -------------------------------------------------------------------------*/ if ( ( 0 != ucEmpty ) && ( NULL != ptlSTAClient->vosAMSDUChainRoot )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL, "WLAN TL:Non NULL vosAMSDUChainRoot on WLANTL_CleanSTA, " "suspecting a memory corruption")); } ptlSTAClient->vosAMSDUChain = NULL; ptlSTAClient->vosAMSDUChainRoot = NULL; vos_mem_zero( (v_PVOID_t)ptlSTAClient->aucMPDUHeader, WLANTL_MPDU_HEADER_LEN); ptlSTAClient->ucMPDUHeaderLen = 0; /*------------------------------------------------------------------------- Reordering information for the STA -------------------------------------------------------------------------*/ for ( ucIndex = 0; ucIndex < WLAN_MAX_TID ; ucIndex++) { if(0 == ptlSTAClient->atlBAReorderInfo[ucIndex].ucExists) { continue; } if(NULL != ptlSTAClient->atlBAReorderInfo[ucIndex].reorderBuffer) { ptlSTAClient->atlBAReorderInfo[ucIndex].reorderBuffer->isAvailable = VOS_TRUE; memset(&ptlSTAClient->atlBAReorderInfo[ucIndex].reorderBuffer->arrayBuffer[0], 0, WLANTL_MAX_WINSIZE * sizeof(v_PVOID_t)); } vos_timer_destroy(&ptlSTAClient->atlBAReorderInfo[ucIndex].agingTimer); memset(&ptlSTAClient->atlBAReorderInfo[ucIndex], 0, sizeof(WLANTL_BAReorderType)); } /*------------------------------------------------------------------------- QOS information for the STA -------------------------------------------------------------------------*/ ptlSTAClient->ucCurrentAC = WLANTL_AC_HIGH_PRIO; ptlSTAClient->ucCurrentWeight = 0; ptlSTAClient->ucServicedAC = WLANTL_AC_BK; vos_mem_zero( ptlSTAClient->aucACMask, sizeof(ptlSTAClient->aucACMask)); vos_mem_zero( &ptlSTAClient->wUAPSDInfo, sizeof(ptlSTAClient->wUAPSDInfo)); /*-------------------------------------------------------------------- Stats info --------------------------------------------------------------------*/ vos_mem_zero( ptlSTAClient->auRxCount, sizeof(ptlSTAClient->auRxCount[0])* WLAN_MAX_TID); vos_mem_zero( ptlSTAClient->auTxCount, sizeof(ptlSTAClient->auTxCount[0])* WLAN_MAX_TID); ptlSTAClient->rssiAvg = 0; /*Tx not suspended and station fully registered*/ vos_atomic_set_U8( &ptlSTAClient->ucTxSuspended, 0); vos_atomic_set_U8( &ptlSTAClient->ucNoMoreData, 1); if ( 0 == ucEmpty ) { ptlSTAClient->wSTADesc.ucUcastSig = WLAN_TL_INVALID_U_SIG; ptlSTAClient->wSTADesc.ucBcastSig = WLAN_TL_INVALID_B_SIG; } ptlSTAClient->ucExists = 0; /*-------------------------------------------------------------------- Statistics info --------------------------------------------------------------------*/ memset(&ptlSTAClient->trafficStatistics, 0, sizeof(WLANTL_TRANSFER_STA_TYPE)); /*fix me!!: add new values from the TL Cb for cleanup */ return VOS_STATUS_SUCCESS; }/* WLANTL_CleanSTA */ /*========================================================================== FUNCTION WLANTL_EnableUAPSDForAC DESCRIPTION Called by HDD to enable UAPSD. TL in turn calls WDA API to enable the logic in FW/SLM to start sending trigger frames. Previously TL had the trigger frame logic which later moved down to FW. Hence HDD -> TL -> WDA -> FW call flow. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: station Id ucAC: AC for which U-APSD is being enabled ucTid: TID for which U-APSD is setup ucUP: used to place in the trigger frame generation ucServiceInt: service interval used by TL to send trigger frames ucSuspendInt: suspend interval used by TL to determine that an app is idle and should start sending trigg frms less often wTSDir: direction of TSpec RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_EnableUAPSDForAC ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_ACEnumType ucAC, v_U8_t ucTid, v_U8_t ucUP, v_U32_t uServiceInt, v_U32_t uSuspendInt, WLANTL_TSDirType wTSDir ) { WLANTL_CbType* pTLCb = NULL; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; tUapsdInfo halUAPSDInfo; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (( NULL == pTLCb ) || WLANTL_STA_ID_INVALID( ucSTAId ) || WLANTL_AC_INVALID(ucAC)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid input params on WLANTL_EnableUAPSDForAC" " TL: %pK STA: %d AC: %d", pTLCb, ucSTAId, ucAC)); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*Set this flag in order to remember that this is a trigger enabled AC*/ pTLCb->atlSTAClients[ucSTAId]->wUAPSDInfo[ucAC].ucSet = 1; #ifdef FEATURE_WLAN_TDLS if(pTLCb->atlSTAClients[ucSTAId]->wSTADesc.wSTAType != WLAN_STA_TDLS) #endif { if( 0 == uServiceInt ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Input params on WLANTL_EnableUAPSDForAC" " SI: %d", uServiceInt )); } TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Enabling U-APSD in FW for STA: %d AC: %d SI: %d SPI: %d " "DI: %d", ucSTAId, ucAC, uServiceInt, uSuspendInt, pTLCb->tlConfigInfo.uDelayedTriggerFrmInt)); /*Save all info for HAL*/ halUAPSDInfo.staidx = ucSTAId; halUAPSDInfo.ac = ucAC; halUAPSDInfo.up = ucUP; halUAPSDInfo.srvInterval = uServiceInt; halUAPSDInfo.susInterval = uSuspendInt; halUAPSDInfo.delayInterval = pTLCb->tlConfigInfo.uDelayedTriggerFrmInt; /*Notify HAL*/ vosStatus = WDA_EnableUapsdAcParams(pvosGCtx, ucSTAId, &halUAPSDInfo); } return vosStatus; }/*WLANTL_EnableUAPSDForAC*/ /*========================================================================== FUNCTION WLANTL_DisableUAPSDForAC DESCRIPTION Called by HDD to disable UAPSD. TL in turn calls WDA API to disable the logic in FW/SLM to stop sending trigger frames. Previously TL had the trigger frame logic which later moved down to FW. Hence HDD -> TL -> WDA -> FW call flow. DEPENDENCIES The TL must be initialized before this function can be called. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: station Id ucAC: AC for which U-APSD is being enabled RETURN VALUE The result code associated with performing the operation VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_DisableUAPSDForAC ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, WLANTL_ACEnumType ucAC ) { WLANTL_CbType* pTLCb; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (( NULL == pTLCb ) || WLANTL_STA_ID_INVALID( ucSTAId ) || WLANTL_AC_INVALID(ucAC) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid input params on WLANTL_DisableUAPSDForAC" " TL: %pK STA: %d AC: %d", pTLCb, ucSTAId, ucAC )); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } /*Reset this flag as this is no longer a trigger enabled AC*/ pTLCb->atlSTAClients[ucSTAId]->wUAPSDInfo[ucAC].ucSet = 1; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Disabling U-APSD in FW for STA: %d AC: %d ", ucSTAId, ucAC)); /*Notify HAL*/ WDA_DisableUapsdAcParams(pvosGCtx, ucSTAId, ucAC); return VOS_STATUS_SUCCESS; }/* WLANTL_DisableUAPSDForAC */ #if defined WLAN_FEATURE_NEIGHBOR_ROAMING /*========================================================================== FUNCTION WLANTL_RegRSSIIndicationCB DESCRIPTION Registration function to get notification if RSSI cross threshold. Client should register threshold, direction, and notification callback function pointer DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in rssiValue - RSSI threshold value in triggerEvent - Cross direction should be notified UP, DOWN, and CROSS in crossCBFunction - Notification CB Function in usrCtxt - user context RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_RegRSSIIndicationCB ( v_PVOID_t pAdapter, v_S7_t rssiValue, v_U8_t triggerEvent, WLANTL_RSSICrossThresholdCBType crossCBFunction, VOS_MODULE_ID moduleID, v_PVOID_t usrCtxt ) { VOS_STATUS status = VOS_STATUS_SUCCESS; status = WLANTL_HSRegRSSIIndicationCB(pAdapter, rssiValue, triggerEvent, crossCBFunction, moduleID, usrCtxt); return status; } /*========================================================================== FUNCTION WLANTL_DeregRSSIIndicationCB DESCRIPTION Remove specific threshold from list DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in rssiValue - RSSI threshold value in triggerEvent - Cross direction should be notified UP, DOWN, and CROSS RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_DeregRSSIIndicationCB ( v_PVOID_t pAdapter, v_S7_t rssiValue, v_U8_t triggerEvent, WLANTL_RSSICrossThresholdCBType crossCBFunction, VOS_MODULE_ID moduleID ) { VOS_STATUS status = VOS_STATUS_SUCCESS; status = WLANTL_HSDeregRSSIIndicationCB(pAdapter, rssiValue, triggerEvent, crossCBFunction, moduleID); return status; } /*========================================================================== FUNCTION WLANTL_SetAlpha DESCRIPTION ALPLA is weight value to calculate AVG RSSI avgRSSI = (ALPHA * historyRSSI) + ((10 - ALPHA) * newRSSI) avgRSSI has (ALPHA * 10)% of history RSSI weight and (10 - ALPHA)% of newRSSI weight This portion is dynamically configurable. Default is ? DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in valueAlpah - ALPHA RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_SetAlpha ( v_PVOID_t pAdapter, v_U8_t valueAlpha ) { VOS_STATUS status = VOS_STATUS_SUCCESS; status = WLANTL_HSSetAlpha(pAdapter, valueAlpha); return status; } /*========================================================================== FUNCTION DESCRIPTION PARAMETERS RETURN VALUE ============================================================================*/ VOS_STATUS WLANTL_BMPSRSSIRegionChangedNotification ( v_PVOID_t pAdapter, tpSirRSSINotification pRSSINotification ) { VOS_STATUS status = VOS_STATUS_SUCCESS; status = WLANTL_HSBMPSRSSIRegionChangedNotification(pAdapter, pRSSINotification); return status; } /*========================================================================== FUNCTION WLANTL_RegGetTrafficStatus DESCRIPTION Registration function for traffic status monitoring During measure period count data frames. If frame count is larger then IDLE threshold set as traffic ON or OFF. And traffic status is changed send report to client with registered callback function DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in idleThreshold - Traffic on or off threshold in measurePeriod - Traffic state check period in trfficStatusCB - traffic status changed notification CB function in usrCtxt - user context RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_RegGetTrafficStatus ( v_PVOID_t pAdapter, v_U32_t idleThreshold, v_U32_t measurePeriod, WLANTL_TrafficStatusChangedCBType trfficStatusCB, v_PVOID_t usrCtxt ) { VOS_STATUS status = VOS_STATUS_SUCCESS; status = WLANTL_HSRegGetTrafficStatus(pAdapter, idleThreshold, measurePeriod, trfficStatusCB, usrCtxt); return status; } #endif /*========================================================================== FUNCTION WLANTL_GetStatistics DESCRIPTION Get traffic statistics for identified station DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in statType - specific statistics field to reset out statBuffer - traffic statistics buffer RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_GetStatistics ( v_PVOID_t pAdapter, WLANTL_TRANSFER_STA_TYPE *statBuffer, v_U8_t STAid ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); WLANTL_STAClientType* pClientSTA = NULL; VOS_STATUS status = VOS_STATUS_SUCCESS; WLANTL_TRANSFER_STA_TYPE *statistics = NULL; /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[STAid]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if(0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: %d STA ID does not exist", STAid)); return VOS_STATUS_E_INVAL; } if(NULL == statBuffer) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL statistics buffer pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_INVAL; } statistics = &pClientSTA->trafficStatistics; vos_mem_copy(statBuffer, statistics, sizeof(WLANTL_TRANSFER_STA_TYPE)); return status; } /*========================================================================== FUNCTION WLANTL_ResetStatistics DESCRIPTION Reset statistics structure for identified station ID Reset means set values as 0 DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in statType - specific statistics field to reset RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_ResetStatistics ( v_PVOID_t pAdapter, v_U8_t STAid ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); WLANTL_STAClientType* pClientSTA = NULL; VOS_STATUS status = VOS_STATUS_SUCCESS; WLANTL_TRANSFER_STA_TYPE *statistics = NULL; /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[STAid]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if(0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: %d STA ID does not exist", STAid)); return VOS_STATUS_E_INVAL; } statistics = &pClientSTA->trafficStatistics; vos_mem_zero((v_VOID_t *)statistics, sizeof(WLANTL_TRANSFER_STA_TYPE)); return status; } /*========================================================================== FUNCTION WLANTL_GetSpecStatistic DESCRIPTION Get specific field within statistics structure for identified station ID DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in statType - specific statistics field to reset in STAid - Station ID out buffer - Statistic value RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_GetSpecStatistic ( v_PVOID_t pAdapter, WLANTL_TRANSFER_STATIC_TYPE statType, v_U32_t *buffer, v_U8_t STAid ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); WLANTL_STAClientType* pClientSTA = NULL; VOS_STATUS status = VOS_STATUS_SUCCESS; WLANTL_TRANSFER_STA_TYPE *statistics = NULL; /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[STAid]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if(0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: %d STA ID does not exist", STAid)); return VOS_STATUS_E_INVAL; } if(NULL == buffer) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL statistic buffer pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_INVAL; } statistics = &pClientSTA->trafficStatistics; switch(statType) { case WLANTL_STATIC_TX_UC_FCNT: *buffer = statistics->txUCFcnt; break; case WLANTL_STATIC_TX_MC_FCNT: *buffer = statistics->txMCFcnt; break; case WLANTL_STATIC_TX_BC_FCNT: *buffer = statistics->txBCFcnt; break; case WLANTL_STATIC_TX_UC_BCNT: *buffer = statistics->txUCBcnt; break; case WLANTL_STATIC_TX_MC_BCNT: *buffer = statistics->txMCBcnt; break; case WLANTL_STATIC_TX_BC_BCNT: *buffer = statistics->txBCBcnt; break; case WLANTL_STATIC_RX_UC_FCNT: *buffer = statistics->rxUCFcnt; break; case WLANTL_STATIC_RX_MC_FCNT: *buffer = statistics->rxMCFcnt; break; case WLANTL_STATIC_RX_BC_FCNT: *buffer = statistics->rxBCFcnt; break; case WLANTL_STATIC_RX_UC_BCNT: *buffer = statistics->rxUCBcnt; break; case WLANTL_STATIC_RX_MC_BCNT: *buffer = statistics->rxMCBcnt; break; case WLANTL_STATIC_RX_BC_BCNT: *buffer = statistics->rxBCBcnt; break; case WLANTL_STATIC_RX_BCNT: *buffer = statistics->rxBcnt; break; case WLANTL_STATIC_RX_BCNT_CRC_OK: *buffer = statistics->rxBcntCRCok; break; case WLANTL_STATIC_RX_RATE: *buffer = statistics->rxRate; break; default: *buffer = 0; status = VOS_STATUS_E_INVAL; break; } return status; } /*========================================================================== FUNCTION WLANTL_ResetSpecStatistic DESCRIPTION Reset specific field within statistics structure for identified station ID Reset means set as 0 DEPENDENCIES NONE PARAMETERS in pAdapter - Global handle in statType - specific statistics field to reset in STAid - Station ID RETURN VALUE VOS_STATUS SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_ResetSpecStatistic ( v_PVOID_t pAdapter, WLANTL_TRANSFER_STATIC_TYPE statType, v_U8_t STAid ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); WLANTL_STAClientType* pClientSTA = NULL; VOS_STATUS status = VOS_STATUS_SUCCESS; WLANTL_TRANSFER_STA_TYPE *statistics = NULL; /*------------------------------------------------------------------------ Sanity check Extract TL control block ------------------------------------------------------------------------*/ if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer on WLANTL_GetStatistics")); return VOS_STATUS_E_FAULT; } pClientSTA = pTLCb->atlSTAClients[STAid]; if ( NULL == pClientSTA ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } if(0 == pClientSTA->ucExists) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: %d STA ID does not exist", STAid)); return VOS_STATUS_E_INVAL; } statistics = &pClientSTA->trafficStatistics; switch(statType) { case WLANTL_STATIC_TX_UC_FCNT: statistics->txUCFcnt = 0; break; case WLANTL_STATIC_TX_MC_FCNT: statistics->txMCFcnt = 0; break; case WLANTL_STATIC_TX_BC_FCNT: statistics->txBCFcnt = 0; break; case WLANTL_STATIC_TX_UC_BCNT: statistics->txUCBcnt = 0; break; case WLANTL_STATIC_TX_MC_BCNT: statistics->txMCBcnt = 0; break; case WLANTL_STATIC_TX_BC_BCNT: statistics->txBCBcnt = 0; break; case WLANTL_STATIC_RX_UC_FCNT: statistics->rxUCFcnt = 0; break; case WLANTL_STATIC_RX_MC_FCNT: statistics->rxMCFcnt = 0; break; case WLANTL_STATIC_RX_BC_FCNT: statistics->rxBCFcnt = 0; break; case WLANTL_STATIC_RX_UC_BCNT: statistics->rxUCBcnt = 0; break; case WLANTL_STATIC_RX_MC_BCNT: statistics->rxMCBcnt = 0; break; case WLANTL_STATIC_RX_BC_BCNT: statistics->rxBCBcnt = 0; break; case WLANTL_STATIC_RX_BCNT: statistics->rxBcnt = 0; break; case WLANTL_STATIC_RX_BCNT_CRC_OK: statistics->rxBcntCRCok = 0; break; case WLANTL_STATIC_RX_RATE: statistics->rxRate = 0; break; default: status = VOS_STATUS_E_INVAL; break; } return status; } /*========================================================================== FUNCTION DESCRIPTION Read RSSI value out of a RX BD PARAMETERS: Caller must validate all parameters RETURN VALUE ============================================================================*/ VOS_STATUS WLANTL_ReadRSSI ( v_PVOID_t pAdapter, v_PVOID_t pBDHeader, v_U8_t STAid ) { WLANTL_CbType *tlCtxt = VOS_GET_TL_CB(pAdapter); v_S7_t currentRSSI, currentRSSI0, currentRSSI1; if(NULL == tlCtxt) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Invalid TL handle", __func__)); return VOS_STATUS_E_INVAL; } if ( NULL == tlCtxt->atlSTAClients[STAid] ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } currentRSSI0 = WLANTL_GETRSSI0(pBDHeader); currentRSSI1 = WLANTL_GETRSSI1(pBDHeader); currentRSSI = (currentRSSI0 > currentRSSI1) ? currentRSSI0 : currentRSSI1; tlCtxt->atlSTAClients[STAid]->rssiAvg = currentRSSI; return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION DESCRIPTION Read SNR value out of a RX BD PARAMETERS: Caller must validate all parameters RETURN VALUE ============================================================================*/ VOS_STATUS WLANTL_ReadSNR ( v_PVOID_t pAdapter, v_PVOID_t pBDHeader, v_U8_t STAid ) { WLANTL_CbType *tlCtxt = VOS_GET_TL_CB(pAdapter); v_S7_t currentSNR; if (NULL == tlCtxt) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Invalid TL handle", __func__)); return VOS_STATUS_E_INVAL; } if (NULL == tlCtxt->atlSTAClients[STAid]) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Client Memory was not allocated on %s", __func__)); return VOS_STATUS_E_FAILURE; } currentSNR = WLANTL_GETSNR(pBDHeader); /* SNR reported in the Buffer Descriptor is scaled up by 2(SNR*2), * Get the correct SNR value */ currentSNR = currentSNR >> 1; /* SNR reported by HW cannot be more than 35dB due to HW limitations */ currentSNR = (WLANTL_MAX_HW_SNR > currentSNR ? currentSNR : WLANTL_MAX_HW_SNR); TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "%s: snrsum: %d snridx: %d prevsnravg: %d", __func__, tlCtxt->atlSTAClients[STAid]->snrSum, tlCtxt->atlSTAClients[STAid]->snrIdx, tlCtxt->atlSTAClients[STAid]->prevSnrAvg)); /* The SNR returned for all purposes is the average SNR over * WLANTL_MAX_SNR_DATA_SMAPLES.When data samples * > WLANTL_MAX_SNR_DATA_SAMPLES are obtained, * store the average of the samples in prevSnrAvg * and start a new averaging window. The prevSnrAvg is used when * enough data samples are not available when applications * actually query for SNR. * * SEE: WLANTL_GetSnr() */ if (tlCtxt->atlSTAClients[STAid]->snrIdx >= WLANTL_MAX_SNR_DATA_SAMPLES) { tlCtxt->atlSTAClients[STAid]->prevSnrAvg = tlCtxt->atlSTAClients[STAid]->snrSum / tlCtxt->atlSTAClients[STAid]->snrIdx; tlCtxt->atlSTAClients[STAid]->snrSum = 0; tlCtxt->atlSTAClients[STAid]->snrIdx = 0; } tlCtxt->atlSTAClients[STAid]->snrSum += currentSNR; tlCtxt->atlSTAClients[STAid]->snrIdx += 1; return VOS_STATUS_SUCCESS; } /* DESCRIPTION TL returns the weight currently maintained in TL. IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context OUT pACWeights: Caller allocated memory for filling in weights RETURN VALUE VOS_STATUS */ VOS_STATUS WLANTL_GetACWeights ( v_PVOID_t pvosGCtx, v_U8_t* pACWeights ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pACWeights ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetACWeights")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetACWeights")); return VOS_STATUS_E_FAULT; } for ( ucIndex = 0; ucIndex < WLANTL_MAX_AC ; ucIndex++) { pACWeights[ucIndex] = pTLCb->tlConfigInfo.ucAcWeights[ucIndex]; } return VOS_STATUS_SUCCESS; } /* DESCRIPTION Change the weight currently maintained by TL. IN pvosGCtx: pointer to the global vos context; a handle to TL's or SME's control block can be extracted from its context pACWeights: Caller allocated memory contain the weights to use RETURN VALUE VOS_STATUS */ VOS_STATUS WLANTL_SetACWeights ( v_PVOID_t pvosGCtx, v_U8_t* pACWeights ) { WLANTL_CbType* pTLCb = NULL; v_U8_t ucIndex; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == pACWeights ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid parameter sent on WLANTL_GetACWeights")); return VOS_STATUS_E_INVAL; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetACWeights")); return VOS_STATUS_E_FAULT; } for ( ucIndex = 0; ucIndex < WLANTL_MAX_AC ; ucIndex++) { pTLCb->tlConfigInfo.ucAcWeights[ucIndex] = pACWeights[ucIndex]; } pTLCb->tlConfigInfo.ucAcWeights[WLANTL_AC_HIGH_PRIO] = pACWeights[WLANTL_AC_VO]; return VOS_STATUS_SUCCESS; } /*========================================================================== FUNCTION DESCRIPTION PARAMETERS RETURN VALUE ============================================================================*/ void WLANTL_PowerStateChangedCB ( v_PVOID_t pAdapter, tPmcState newState ) { WLANTL_CbType *tlCtxt = VOS_GET_TL_CB(pAdapter); if (NULL == tlCtxt) { VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL Control Block", __func__ ); return; } VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Power state changed, new state is %d", newState ); switch(newState) { case FULL_POWER: tlCtxt->isBMPS = VOS_FALSE; break; case BMPS: #if defined WLAN_FEATURE_NEIGHBOR_ROAMING WLANTL_SetFWRSSIThresholds(pAdapter); #endif tlCtxt->isBMPS = VOS_TRUE; break; case IMPS: case LOW_POWER: case REQUEST_BMPS: case REQUEST_FULL_POWER: case REQUEST_IMPS: case STOPPED: case REQUEST_START_UAPSD: case REQUEST_STOP_UAPSD: case UAPSD: case REQUEST_STANDBY: case STANDBY: case REQUEST_ENTER_WOWL: case REQUEST_EXIT_WOWL: case WOWL: TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, "Not handle this events %d", newState )); break; default: TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Not a valid event %d", newState )); break; } return; } /*========================================================================== FUNCTION WLANTL_GetEtherType DESCRIPTION Extract Ether type information from the BD DEPENDENCIES NONE PARAMETERS in aucBDHeader - BD header in vosDataBuff - data buffer in ucMPDUHLen - MPDU header length out pUsEtherType - pointer to Ethertype RETURN VALUE VOS_STATUS_SUCCESS : if the EtherType is successfully extracted VOS_STATUS_FAILURE : if the EtherType extraction failed and the packet was dropped SIDE EFFECTS NONE ============================================================================*/ static VOS_STATUS WLANTL_GetEtherType ( v_U8_t * aucBDHeader, vos_pkt_t * vosDataBuff, v_U8_t ucMPDUHLen, v_U16_t * pUsEtherType ) { v_U8_t ucOffset; v_U16_t usEtherType = *pUsEtherType; v_SIZE_t usLLCSize = sizeof(usEtherType); VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; /*------------------------------------------------------------------------ Check if LLC is present - if not, TL is unable to determine type ------------------------------------------------------------------------*/ if ( VOS_FALSE == WDA_IS_RX_LLC_PRESENT( aucBDHeader ) ) { ucOffset = WLANTL_802_3_HEADER_LEN - sizeof(usEtherType); } else { ucOffset = ucMPDUHLen + WLANTL_LLC_PROTO_TYPE_OFFSET; } /*------------------------------------------------------------------------ Extract LLC type ------------------------------------------------------------------------*/ vosStatus = vos_pkt_extract_data( vosDataBuff, ucOffset, (v_PVOID_t)&usEtherType, &usLLCSize); if (( VOS_STATUS_SUCCESS != vosStatus ) || ( sizeof(usEtherType) != usLLCSize )) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Error extracting Ether type from data packet")); /* Drop packet */ vos_pkt_return_packet(vosDataBuff); vosStatus = VOS_STATUS_E_FAILURE; } else { TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Ether type retrieved before endianess conv: %d", usEtherType)); usEtherType = vos_be16_to_cpu(usEtherType); *pUsEtherType = usEtherType; TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL:Ether type retrieved: %d", usEtherType)); } return vosStatus; } /*========================================================================== FUNCTION WLANTL_GetSoftAPStatistics DESCRIPTION Collect the cumulative statistics for all Softap stations DEPENDENCIES NONE PARAMETERS in pvosGCtx - Pointer to the global vos context bReset - If set TL statistics will be cleared after reading out statsSum - pointer to collected statistics RETURN VALUE VOS_STATUS_SUCCESS : if the Statistics are successfully extracted SIDE EFFECTS NONE ============================================================================*/ VOS_STATUS WLANTL_GetSoftAPStatistics(v_PVOID_t pAdapter, WLANTL_TRANSFER_STA_TYPE *statsSum, v_BOOL_t bReset) { v_U8_t i = 0; VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); WLANTL_TRANSFER_STA_TYPE statBufferTemp; vos_mem_zero((v_VOID_t *)&statBufferTemp, sizeof(WLANTL_TRANSFER_STA_TYPE)); vos_mem_zero((v_VOID_t *)statsSum, sizeof(WLANTL_TRANSFER_STA_TYPE)); if ( NULL == pTLCb ) { return VOS_STATUS_E_FAULT; } // Sum up all the statistics for stations of Soft AP from TL for (i = 0; i < WLAN_MAX_STA_COUNT; i++) { if ( NULL == pTLCb->atlSTAClients[i]) { continue; } if (pTLCb->atlSTAClients[i]->wSTADesc.wSTAType == WLAN_STA_SOFTAP) { vosStatus = WLANTL_GetStatistics(pAdapter, &statBufferTemp, i);// Can include staId 1 because statistics not collected for it if (!VOS_IS_STATUS_SUCCESS(vosStatus)) return VOS_STATUS_E_FAULT; // Add to the counters statsSum->txUCFcnt += statBufferTemp.txUCFcnt; statsSum->txMCFcnt += statBufferTemp.txMCFcnt; statsSum->txBCFcnt += statBufferTemp.txBCFcnt; statsSum->txUCBcnt += statBufferTemp.txUCBcnt; statsSum->txMCBcnt += statBufferTemp.txMCBcnt; statsSum->txBCBcnt += statBufferTemp.txBCBcnt; statsSum->rxUCFcnt += statBufferTemp.rxUCFcnt; statsSum->rxMCFcnt += statBufferTemp.rxMCFcnt; statsSum->rxBCFcnt += statBufferTemp.rxBCFcnt; statsSum->rxUCBcnt += statBufferTemp.rxUCBcnt; statsSum->rxMCBcnt += statBufferTemp.rxMCBcnt; statsSum->rxBCBcnt += statBufferTemp.rxBCBcnt; if (bReset) { vosStatus = WLANTL_ResetStatistics(pAdapter, i); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) return VOS_STATUS_E_FAULT; } } } return vosStatus; } /*=============================================================================== FUNCTION WLANTL_IsReplayPacket DESCRIPTION This function does replay check for valid stations DEPENDENCIES Validity of replay check must be done before the function is called PARAMETERS currentReplayCounter current replay counter taken from RX BD previousReplayCounter previous replay counter taken from TL CB RETRUN VOS_TRUE packet is a replay packet VOS_FALSE packet is not a replay packet SIDE EFFECTS none ===============================================================================*/ v_BOOL_t WLANTL_IsReplayPacket ( v_U64_t ullcurrentReplayCounter, v_U64_t ullpreviousReplayCounter ) { /* Do the replay check by comparing previous received replay counter with current received replay counter*/ if(ullpreviousReplayCounter < ullcurrentReplayCounter) { /* Valid packet not replay */ return VOS_FALSE; } else { /* Current packet number is less than or equal to previuos received packet no, this means current packet is replay packet */ VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Replay packet found with replay counter :[0x%llX]",ullcurrentReplayCounter); return VOS_TRUE; } } #if 0 /*=============================================================================== FUNCTION WLANTL_GetReplayCounterFromRxBD DESCRIPTION This function extracts 48-bit replay packet number from RX BD DEPENDENCIES Validity of replay check must be done before the function is called PARAMETERS pucRxHeader pointer to RX BD header RETRUN v_U64_t Packet number extarcted from RX BD SIDE EFFECTS none ===============================================================================*/ v_U64_t WLANTL_GetReplayCounterFromRxBD ( v_U8_t *pucRxBDHeader ) { /* 48-bit replay counter is created as follows from RX BD 6 byte PMI command: Addr : AES/TKIP 0x38 : pn3/tsc3 0x39 : pn2/tsc2 0x3a : pn1/tsc1 0x3b : pn0/tsc0 0x3c : pn5/tsc5 0x3d : pn4/tsc4 */ #ifdef ANI_BIG_BYTE_ENDIAN v_U64_t ullcurrentReplayCounter = 0; /* Getting 48-bit replay counter from the RX BD */ ullcurrentReplayCounter = WLANHAL_RX_BD_GET_PMICMD_20TO23(pucRxBDHeader); ullcurrentReplayCounter <<= 16; ullcurrentReplayCounter |= (( WLANHAL_RX_BD_GET_PMICMD_24TO25(pucRxBDHeader) & 0xFFFF0000) >> 16); return ullcurrentReplayCounter; #else v_U64_t ullcurrentReplayCounter = 0; /* Getting 48-bit replay counter from the RX BD */ ullcurrentReplayCounter = (WLANHAL_RX_BD_GET_PMICMD_24TO25(pucRxBDHeader) & 0x0000FFFF); ullcurrentReplayCounter <<= 32; ullcurrentReplayCounter |= WLANHAL_RX_BD_GET_PMICMD_20TO23(pucRxBDHeader); return ullcurrentReplayCounter; #endif } #endif /*=============================================================================== FUNCTION WLANTL_PostResNeeded DESCRIPTION This function posts message to TL to reserve BD/PDU memory DEPENDENCIES None PARAMETERS pvosGCtx RETURN None SIDE EFFECTS none ===============================================================================*/ void WLANTL_PostResNeeded(v_PVOID_t pvosGCtx) { vos_msg_t vosMsg; vosMsg.reserved = 0; vosMsg.bodyptr = NULL; vosMsg.type = WLANTL_TX_RES_NEEDED; VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH, "WLAN TL: BD/PDU available interrupt received, Posting message to TL"); if(!VOS_IS_STATUS_SUCCESS(vos_tx_mq_serialize( VOS_MQ_ID_TL, &vosMsg))) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s fails to post message", __func__); } } /*=============================================================================== FUNCTION WLANTL_UpdateRssiBmps DESCRIPTION This function updates the TL's RSSI (in BMPS mode) DEPENDENCIES None PARAMETERS pvosGCtx VOS context VOS Global context staId Station ID Station ID rssi RSSI (BMPS mode) RSSI in BMPS mode RETURN None SIDE EFFECTS none ===============================================================================*/ void WLANTL_UpdateRssiBmps(v_PVOID_t pvosGCtx, v_U8_t staId, v_S7_t rssi) { WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL != pTLCb && NULL != pTLCb->atlSTAClients[staId]) { pTLCb->atlSTAClients[staId]->rssiAvgBmps = rssi; } } /*=============================================================================== FUNCTION WLANTL_UpdateSnrBmps DESCRIPTION This function updates the TL's SNR (in BMPS mode) DEPENDENCIES None PARAMETERS pvosGCtx VOS context VOS Global context staId Station ID Station ID snr SNR (BMPS mode) SNR in BMPS mode RETURN None SIDE EFFECTS none ===============================================================================*/ void WLANTL_UpdateSnrBmps(v_PVOID_t pvosGCtx, v_U8_t staId, v_S7_t snr) { WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL != pTLCb && NULL != pTLCb->atlSTAClients[staId]) { pTLCb->atlSTAClients[staId]->snrAvgBmps = snr; } } /*=============================================================================== FUNCTION WLANTL_UpdateLinkCapacity DESCRIPTION This function updates the STA's Link Capacity in TL DEPENDENCIES None PARAMETERS pvosGCtx VOS context VOS Global context staId Station ID Station ID linkCapacity linkCapacity Link Capacity RETURN None SIDE EFFECTS none ===============================================================================*/ void WLANTL_UpdateLinkCapacity(v_PVOID_t pvosGCtx, v_U8_t staId, v_U32_t linkCapacity) { WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL != pTLCb && NULL != pTLCb->atlSTAClients[staId]) { pTLCb->atlSTAClients[staId]->linkCapacity = linkCapacity; } } /*=========================================================================== FUNCTION WLANTL_GetSTALinkCapacity DESCRIPTION Returns Link Capacity of a particular STA. DEPENDENCIES A station must have been registered before its state can be retrieved. PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to TL's control block can be extracted from its context ucSTAId: identifier of the station OUT plinkCapacity: the current link capacity the connection to the given station RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_INVAL: Input parameters are invalid VOS_STATUS_E_FAULT: Station ID is outside array boundaries or pointer to TL cb is NULL ; access would cause a page fault VOS_STATUS_E_EXISTS: Station was not registered VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANTL_GetSTALinkCapacity ( v_PVOID_t pvosGCtx, v_U8_t ucSTAId, v_U32_t *plinkCapacity ) { WLANTL_CbType* pTLCb = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( NULL == plinkCapacity ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Invalid parameter"))); return VOS_STATUS_E_INVAL; } if ( WLANTL_STA_ID_INVALID( ucSTAId ) ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Invalid station id"))); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Extract TL control block and check existance ------------------------------------------------------------------------*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Invalid TL pointer from pvosGCtx"))); return VOS_STATUS_E_FAULT; } if ( NULL == pTLCb->atlSTAClients[ucSTAId] ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, FL("WLAN TL:Client Memory was not allocated"))); return VOS_STATUS_E_FAILURE; } if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN, FL("WLAN TL:Station was not previously registered"))); return VOS_STATUS_E_EXISTS; } /*------------------------------------------------------------------------ Get STA state ------------------------------------------------------------------------*/ *plinkCapacity = pTLCb->atlSTAClients[ucSTAId]->linkCapacity; return VOS_STATUS_SUCCESS; }/* WLANTL_GetSTALinkCapacity */ /* * WLANTL_ResetRxSSN - reset last rx ssn * @pvosGCtx: global vos context * @ucSTAId: station id * * This function resets the last ssn of all tids of the station * for whom BA reorder session exists. * * Return: none */ void WLANTL_ResetRxSSN(v_PVOID_t pvosGCtx, uint8_t ucSTAId) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; uint8_t i; if (WLANTL_STA_ID_INVALID(ucSTAId)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid station id requested WLANTL_ResetRxSSN")); return; } pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL:Invalid TL pointer from pvosGCtx WLANTL_ResetRxSSN")); return; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; for (i = 0; i < WLAN_MAX_TID ; i++) { if (0 == pClientSTA->atlBAReorderInfo[i].ucExists) { continue; } TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Last RxSSN reset to zero for tid %d", i)); pClientSTA->atlBAReorderInfo[i].LastSN = 0; } } void WLANTL_SetDataPktFilter(v_PVOID_t pvosGCtx, uint8_t ucSTAId, bool flag) { WLANTL_CbType* pTLCb = NULL; WLANTL_STAClientType* pClientSTA = NULL; uint8_t i; if (WLANTL_STA_ID_INVALID(ucSTAId)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid station id requested", __func__)); return; } pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer from pvosGCtx", __func__)); return; } pClientSTA = pTLCb->atlSTAClients[ucSTAId]; for (i = 0; i < WLAN_MAX_TID ; i++) { if (0 == pClientSTA->atlBAReorderInfo[i].ucExists) continue; TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "WLAN TL: Last RxSSN reset to zero for tid %d", i)); pClientSTA->atlBAReorderInfo[i].set_data_filter = flag; } } /** * WLANTL_ShiftArrByOne() - utility function to shift array by one * @arr: pointer to array * @len: length of the array * * Caller responsibility to provide the correct length of the array * other may leads to bugs. * * Return: void */ static void WLANTL_ShiftArrByOne(uint32_t *arr, uint8_t len) { int i; for (i = 0; i < len - 1; i ++) arr[i] = arr[i + 1]; arr[i] = 0; } /** * WLANTL_SampleTx() - collect tx samples * @data: TL context pointer * * This function records the last five tx bytes sent samples * collected after tx_bytes_timer expire. * * Return: void */ void WLANTL_SampleTx(void *data) { WLANTL_CbType* pTLCb = (WLANTL_CbType *)data; WLANTL_STAClientType* pClientSTA = NULL; uint8_t count = pTLCb->sample_count; uint8_t i; for ( i = 0; i < WLAN_MAX_STA_COUNT; i++) { if (NULL != pTLCb->atlSTAClients[i] && pTLCb->atlSTAClients[i]->ucExists) { pClientSTA = pTLCb->atlSTAClients[i]; if (count > (WLANTL_SAMPLE_COUNT - 1)) { count = WLANTL_SAMPLE_COUNT - 1; pClientSTA->tx_samples_sum -= pClientSTA->tx_sample[0]; WLANTL_ShiftArrByOne(pClientSTA->tx_sample, WLANTL_SAMPLE_COUNT); } pClientSTA->tx_sample[count] = pClientSTA->tx_frames; pClientSTA->tx_samples_sum += pClientSTA->tx_sample[count]; pClientSTA->tx_frames = 0; count++; pTLCb->sample_count = count; } } vos_timer_start(&pTLCb->tx_frames_timer, WLANTL_SAMPLE_INTERVAL); } /** * WLANTL_EnablePreAssocCaching() - Enable caching EAPOL frames * * Return: None * */ void WLANTL_EnablePreAssocCaching(void) { v_PVOID_t pvosGCtx= vos_get_global_context(VOS_MODULE_ID_TL,NULL); WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb ) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer for global context", __func__)); return; } pTLCb->vosEapolCachedFrame = NULL; pTLCb->preassoc_caching = true; } /** * WLANTL_ForwardPreAssoc() - forward cached eapol frames * @flag: Value to forward or flush * * Return: vos status * */ static VOS_STATUS WLANTL_ForwardPreAssoc(bool flag) { vos_msg_t sMessage; VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " ---- Serializing TL for forwarding pre assoc cache frames"); vos_mem_zero( &sMessage, sizeof(vos_msg_t)); sMessage.type = WLANTL_RX_FWD_PRE_ASSOC_CACHED; sMessage.bodyval = flag; return vos_rx_mq_serialize(VOS_MQ_ID_TL, &sMessage); } /** * WLANTL_PreAssocForward() - forward cached eapol frames * @flag: Value to forward or flush * * Return: None * */ void WLANTL_PreAssocForward(bool flag) { if(!VOS_IS_STATUS_SUCCESS(WLANTL_ForwardPreAssoc(flag))) { VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, " %s fails to forward packets", __func__); } } /** * WLANTL_RegisterFwdEapol() - register call back to forward cached eapol frame * @pvosGCtx : pointer to vos global context * @pfnFwdEapol: call back function pointer * * Return: None * */ void WLANTL_RegisterFwdEapol(v_PVOID_t pvosGCtx, WLANTL_FwdEapolCBType pfnFwdEapol) { WLANTL_CbType* pTLCb = NULL; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (pTLCb) pTLCb->pfnEapolFwd = pfnFwdEapol; } /** * WLANTL_SetARPFWDatapath() - keep or remove FW in data path for ARP * * @flag: value to keep or remove FW from data path * * Return: void */ void WLANTL_SetARPFWDatapath(void * pvosGCtx, bool flag) { WLANTL_CbType* pTLCb = NULL; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer from pvosGCtx", __func__)); return; } pTLCb->track_arp = flag; } v_U16_t wlan_tl_get_sta_rx_rate(void *pvosGCtx, uint8_t ucSTAId) { WLANTL_CbType* pTLCb = NULL; v_U16_t rate = 0; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer from pvosGCtx", __func__)); return rate; } if (pTLCb->atlSTAClients[ucSTAId]->ucExists) rate = vos_get_rate_from_rateidx( pTLCb->atlSTAClients[ucSTAId]->rate_idx); return rate; } void WLANTL_GetSAPStaRSSi(void *pvosGCtx, uint8_t ucSTAId, s8 *rssi) { WLANTL_CbType* pTLCb = NULL; uint8_t count; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer from pvosGCtx", __func__)); return; } count = pTLCb->atlSTAClients[ucSTAId]->rssi_sample_cnt; count < WLANTL_RSSI_SAMPLE_CNT ? count++ : count; *rssi = pTLCb->atlSTAClients[ucSTAId]->rssi_sample_sum / count; } void WLANTL_SetKeySeqCounter(void *pvosGCtx, u64 counter, uint8_t staid) { WLANTL_CbType* pTLCb = NULL; uint8_t i; pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid TL pointer from pvosGCtx", __func__)); return; } if (WLANTL_STA_ID_INVALID(staid)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Invalid Sta id passed", __func__)); return; } if (NULL == pTLCb->atlSTAClients[staid]) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s: Station context is NULL", __func__)); return; } for(i = 0; i < WLANTL_MAX_TID; i++) pTLCb->atlSTAClients[staid]->ullReplayCounter[i] = counter; } #ifdef WLAN_FEATURE_RMC VOS_STATUS WLANTL_RmcInit ( v_PVOID_t pAdapter ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); VOS_STATUS status = VOS_STATUS_SUCCESS; tANI_U8 count; /*sanity check*/ if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid TL handle")); return VOS_STATUS_E_INVAL; } for ( count = 0; count < WLANTL_RMC_HASH_TABLE_SIZE; count++ ) { pTLCb->rmcSession[count] = NULL; } vos_lock_init(&pTLCb->rmcLock); pTLCb->multicastDuplicateDetectionEnabled = 1; pTLCb->rmcDataPathEnabled = 0; return status; } VOS_STATUS WLANTL_RmcDeInit ( v_PVOID_t pAdapter ) { WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter); VOS_STATUS status = VOS_STATUS_SUCCESS; tANI_U8 count; WLANTL_RMC_SESSION *pNode; WLANTL_RMC_SESSION *pPrev; /*sanity check*/ if (NULL == pTLCb) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Invalid TL handle")); return VOS_STATUS_E_INVAL; } for ( count = 0; count < WLANTL_RMC_HASH_TABLE_SIZE; count++ ) { pNode = pTLCb->rmcSession[count]; while (pNode) { pPrev = pNode; pNode = pNode->next; vos_mem_free((v_VOID_t * )pPrev); } } vos_lock_destroy(&pTLCb->rmcLock); return status; } tANI_U8 WLANTL_RmcHashRmcSession ( v_MACADDR_t *pMcastAddr ) { tANI_U32 sum; tANI_U8 hash; sum = (pMcastAddr->bytes[0] + pMcastAddr->bytes[1] + pMcastAddr->bytes[2] + pMcastAddr->bytes[3] + pMcastAddr->bytes[4] + pMcastAddr->bytes[5]); hash = (tANI_U8)(sum & ((WLANTL_RMC_HASH_TABLE_SIZE - 1))); return hash; } WLANTL_RMC_SESSION* WLANTL_RmcLookUpRmcSession ( WLANTL_RMC_SESSION *rmcSession[], v_MACADDR_t *pMcastAddr ) { WLANTL_RMC_SESSION *pNode; tANI_U8 index; /*sanity check*/ if (NULL == pMcastAddr) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "Sanity check failed pMcastAddr %pK", pMcastAddr)); return NULL; } index = WLANTL_RmcHashRmcSession(pMcastAddr); pNode = rmcSession[index]; while ( pNode ) { if (vos_is_macaddr_equal( &(pNode->rmcAddr), pMcastAddr)) { return pNode; } pNode = pNode->next; } return NULL; } WLANTL_RMC_SESSION *WLANTL_RmcAddRmcSession ( WLANTL_RMC_SESSION *rmcSession[], v_MACADDR_t *pMcastAddr ) { WLANTL_RMC_SESSION *pNode; tANI_U8 index; index = WLANTL_RmcHashRmcSession(pMcastAddr); pNode = WLANTL_RmcLookUpRmcSession(rmcSession, pMcastAddr); if ( NULL != pNode ) { /*already exists*/ return NULL; } else { pNode = (WLANTL_RMC_SESSION *)vos_mem_malloc(sizeof(*pNode)); if (pNode) { vos_mem_copy( &(pNode->rmcAddr), pMcastAddr, sizeof(pNode->rmcAddr) ); pNode->next = rmcSession[index]; rmcSession[index] = pNode; return pNode; } else { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: vos_mem_malloc failed can't enable RMC session", __func__); return NULL; } } } tANI_U8 WLANTL_RmcDeleteRmcSession ( WLANTL_RMC_SESSION *rmcSession[], v_MACADDR_t *pMcastAddr ) { WLANTL_RMC_SESSION *pHead; WLANTL_RMC_SESSION *pNode; WLANTL_RMC_SESSION *pPrev; tANI_U8 index; index = WLANTL_RmcHashRmcSession(pMcastAddr); pHead = pNode = rmcSession[index]; while (pNode) { if (vos_is_macaddr_equal( &(pNode->rmcAddr), pMcastAddr)) { if (pHead == pNode) { rmcSession[index] = pNode->next; } else { pPrev->next = pNode->next; } vos_mem_free((v_VOID_t * )pNode); return 1; } pPrev = pNode; pNode = pNode->next; } return 0; } VOS_STATUS WLANTL_ProcessRmcCommand ( WLANTL_CbType* pTLCb, v_MACADDR_t *pMcastAddr, tANI_U32 command ) { VOS_STATUS status; tANI_U32 count; tANI_U32 rmcActive; if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire( &(pTLCb->rmcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Get Lock Fail", __func__)); return VOS_STATUS_E_FAILURE; } /*add or delete node from active rmc hash table*/ if (command) { /*add requested rmc session in active rmc session list*/ if (WLANTL_RmcAddRmcSession(pTLCb->rmcSession, pMcastAddr)) { TLLOGE( VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "RMC session " MAC_ADDRESS_STR " added in TL hash table", MAC_ADDR_ARRAY(pMcastAddr->bytes) ) ); pTLCb->rmcDataPathEnabled = TRUE; status = VOS_STATUS_SUCCESS; } else { TLLOGE( VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "RMC session " MAC_ADDRESS_STR " already exists in TL hash" " table", MAC_ADDR_ARRAY(pMcastAddr->bytes) ) ); status = VOS_STATUS_E_FAILURE; } } else { /*delete requested rmc session from active rmc session list*/ if (WLANTL_RmcDeleteRmcSession(pTLCb->rmcSession, pMcastAddr)) { TLLOGE( VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "RMC session " MAC_ADDRESS_STR " deleted from TL hash table", MAC_ADDR_ARRAY(pMcastAddr->bytes)) ); status = VOS_STATUS_SUCCESS; rmcActive = FALSE; for ( count = 0; count < WLANTL_RMC_HASH_TABLE_SIZE; count++ ) { if (pTLCb->rmcSession[count]) { rmcActive = TRUE; break; } } if (TRUE == rmcActive) { pTLCb->rmcDataPathEnabled = TRUE; } else { pTLCb->rmcDataPathEnabled = FALSE; } } else { TLLOGE( VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "RMC session " MAC_ADDRESS_STR " doesn't exist in TL hash" " table", MAC_ADDR_ARRAY(pMcastAddr->bytes) ) ); status = VOS_STATUS_E_FAILURE; } } if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&(pTLCb->rmcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Release Lock Fail", __func__)); return VOS_STATUS_E_FAILURE; } return status; }/* End of WLANTL_ProcessRmcCommand */ VOS_STATUS WLANTL_EnableRMC ( v_PVOID_t pvosGCtx, v_MACADDR_t *pMcastTransmitterAddr ) { WLANTL_CbType* pTLCb; VOS_STATUS status; /*sanity check*/ if ( (NULL == pvosGCtx) || (NULL == pMcastTransmitterAddr) ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: Sanity check failed pvosGCtx %pK aMcastAddr %pK", __func__, pvosGCtx, pMcastTransmitterAddr)); return VOS_STATUS_E_FAILURE; } /*sanity check*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if ( NULL == pTLCb ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: pTLCb is NULL", __func__)); return VOS_STATUS_E_FAILURE; } status = WLANTL_ProcessRmcCommand(pTLCb, pMcastTransmitterAddr , 1); return status; } /* End of WLANTL_EnableRMC */ VOS_STATUS WLANTL_DisableRMC ( v_PVOID_t pvosGCtx, v_MACADDR_t *pMcastTransmitterAddr ) { WLANTL_CbType* pTLCb; VOS_STATUS status; /*Sanity check*/ if ((NULL == pvosGCtx) || (NULL == pMcastTransmitterAddr)) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: Sanity check failed pvosGCtx %pK aMcastAddr %pK", __func__, pvosGCtx, pMcastTransmitterAddr)); return VOS_STATUS_E_FAILURE; } /*Sanity check*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: pTLCb is NULL", __func__)); return VOS_STATUS_E_FAILURE; } status = WLANTL_ProcessRmcCommand(pTLCb, pMcastTransmitterAddr, 0); return status; } /* End of WLANTL_DisableRMC */ /*============================================================================= Duplicate Multicast Detection Functions ==============================================================================*/ /*============================================================================= FUNCTION WLANTL_IsDuplicateMcastFrm DESCRIPTION This function checks for duplicast multicast frames and drops them. DEPENDENCIES PARAMETERS IN pClientSTA : Pointer to WLANTL_STAClientType aucBDHeader : Pointer to BD header RETURN VALUE VOS_FALSE: This frame is not a duplicate VOS_TRUE: This frame is a duplicate ==============================================================================*/ v_U8_t WLANTL_IsDuplicateMcastFrm ( WLANTL_STAClientType *pClientSTA, vos_pkt_t *vosDataBuff ) { v_U8_t duplicate = VOS_FALSE; WLANTL_RMC_SESSION *pNode; v_U16_t usSeqCtrl; v_MACADDR_t mcastAddr; VOS_STATUS vosStatus; v_PVOID_t pvPeekData; /* Get address 1 of Data Frame */ vosStatus = vos_pkt_peek_data(vosDataBuff, WLANTL_MAC_ADDR_ALIGN(1), (v_PVOID_t)&pvPeekData, VOS_MAC_ADDR_SIZE); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to get Addr 1 of 80211 header from packet %d", vosStatus)); return VOS_FALSE; } /* Copy address 1 of Data Frame */ vos_mem_copy(&mcastAddr.bytes, pvPeekData, VOS_MAC_ADDR_SIZE); /* * We perform duplicate detection for only multicast data frames */ if (vos_is_macaddr_group(&mcastAddr) && !vos_is_macaddr_broadcast(&mcastAddr)) { /* Get sequence control of Data Frame */ vosStatus = vos_pkt_peek_data(vosDataBuff, (WLANTL_MAC_ADDR_ALIGN(1) + (3 * VOS_MAC_ADDR_SIZE)), (v_PVOID_t)&pvPeekData, sizeof(v_U16_t)); if ( VOS_STATUS_SUCCESS != vosStatus ) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Failed to get Sequence Control from packet %d", vosStatus)); return VOS_FALSE; } /* Copy sequence control from the Data Frame */ usSeqCtrl = *(v_U16_t *)pvPeekData; if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&(pClientSTA->mcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Get Lock Fail", __func__)); return VOS_FALSE; } pNode = WLANTL_RmcLookUpRmcSession(pClientSTA->mcastSession, &mcastAddr); if (NULL == pNode) { /* If the session does not exist, add it. */ pNode = WLANTL_RmcAddRmcSession(pClientSTA->mcastSession, &mcastAddr); /* If we could not add a entry, skip duplicate detection */ if (NULL == pNode) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Failed to add multicast session", __func__)); if (!VOS_IS_STATUS_SUCCESS (vos_lock_release(&(pClientSTA->mcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Release Lock Fail", __func__)); } return VOS_FALSE; } /* Initialize the sequence control value. */ pNode->mcSeqCtl = usSeqCtrl; } else { /* * Check if the sequence number of this frame matches the last * we have seen. */ if (pNode->mcSeqCtl == usSeqCtrl) { pNode->rxMCDupcnt++; TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s Rx Multicast Duplicate %d " MAC_ADDRESS_STR " (Seq %x)", __func__, pNode->rxMCDupcnt, MAC_ADDR_ARRAY(mcastAddr.bytes), usSeqCtrl)); duplicate = VOS_TRUE; } else { /* Update the last seen sequence number */ pNode->mcSeqCtl = usSeqCtrl; } } if (!VOS_IS_STATUS_SUCCESS (vos_lock_release(&(pClientSTA->mcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Release Lock Fail", __func__)); } } return duplicate; } /*============================================================================= FUNCTION WLANTL_McastDeleteAllEntries DESCRIPTION This function removes all multicast entries used for duplicate detection DEPENDENCIES PARAMETERS IN pClientSTA : Pointer to WLANTL_STAClientType RETURN VALUE None ==============================================================================*/ void WLANTL_McastDeleteAllEntries(WLANTL_STAClientType * pClientSTA) { WLANTL_RMC_SESSION *pNode, **head; int index; TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "%s Deleting all multicast entries", __func__)); if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&(pClientSTA->mcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Get Lock Fail", __func__)); return; } for (index = 0; index < WLANTL_RMC_HASH_TABLE_SIZE; index++) { head = &pClientSTA->mcastSession[index]; pNode = *head; while (pNode) { *head = pNode->next; /* free the group entry */ vos_mem_free(pNode); pNode = *head; } } if (!VOS_IS_STATUS_SUCCESS (vos_lock_release(&(pClientSTA->mcLock)))) { TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "%s Release Lock Fail", __func__)); } } /*============================================================================= FUNCTION WLANTL_SetMcastDuplicateDetection DESCRIPTION This function sets multicate duplicate detection operation. If enable is 1, the detection is enabled, else it is disabled. DEPENDENCIES PARAMETERS IN pvosGCtx : Pointer to VOS global context enable : Boolean to enable or disable RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: Sanity check on input failed VOS_STATUS_SUCCESS: Everything is good :) Other return values are possible coming from the called functions. Please check API for additional info. SIDE EFFECTS ==============================================================================*/ VOS_STATUS WLANTL_SetMcastDuplicateDetection ( v_PVOID_t pvosGCtx, v_U8_t enable ) { WLANTL_CbType* pTLCb; /*Sanity check*/ if (NULL == pvosGCtx) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: Sanity check failed pvosGCtx %pK", __func__, pvosGCtx)); return VOS_STATUS_E_FAILURE; } /*Sanity check*/ pTLCb = VOS_GET_TL_CB(pvosGCtx); if (NULL == pTLCb) { TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: pTLCb is NULL", __func__)); return VOS_STATUS_E_FAILURE; } switch (enable) { default: /* * Any value other than 0 or 1 is used to dump the * duplicate count. */ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL %s: Multicast Duplicate Count %d", __func__, pTLCb->mcastDupCnt)); break; case 0: case 1: pTLCb->multicastDuplicateDetectionEnabled = enable; break; } return VOS_STATUS_SUCCESS; } #endif /* WLAN_FEATURE_RMC */