Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 0d36bc457a902ff20557c4f0fdf0342c8548aa43 / . / CORE / WDA / src / wlan_qct_wda.c
blob: 29885aa1a0651d66f87d01a1a4f6becf054c94eb [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]2 * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
23 * Copyright (c) 2012-2014 Qualcomm Atheros, Inc.
24 * All Rights Reserved.
25 * Qualcomm Atheros Confidential and Proprietary.
26 *
27 */
28
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]29
30/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 The functions externalized by this module are to be called ONLY by other
35 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]36 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 Are listed for each API below.
38
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]39 Copyright (c) 2010-2011 QUALCOMM Incorporated.
40 All Rights Reserved.
41 Qualcomm Confidential and Proprietary
42===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]43/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44 EDIT HISTORY FOR FILE
45
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]46 This section contains comments describing changes made to the module.
47 Notice that changes are listed in reverse chronological order.
48
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]49 $Header$$DateTime$$Author$
50
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]51 when who what, where, why
52---------- --- -------------------------------------------------
5310/05/2011 haparna Adding support for Keep Alive Feature
542010-12-30 smiryala UMAC convergence changes
552010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
56===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]57#include "vos_mq.h"
58#include "vos_api.h"
59#include "vos_packet.h"
60#include "vos_nvitem.h"
61#include "sirApi.h"
62#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]63#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]64#include "wlan_qct_wda.h"
65#include "wlan_qct_wda_msg.h"
66#include "wlan_qct_wdi_cfg.h"
67#include "wlan_qct_wdi.h"
68#include "wlan_qct_wdi_ds.h"
69#include "wlan_hal_cfg.h"
70/**********************/
71#include "wniApi.h"
72#include "cfgApi.h"
73#include "limApi.h"
74#include "wlan_qct_tl.h"
75#include "wlan_qct_tli_ba.h"
76#include "limUtils.h"
77#include "btcApi.h"
78#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]79#include "pttMsgApi.h"
80#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]81/* Used MACRO's */
82/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]83#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]84#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
85#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]86#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define CONVERT_WDI2SIR_STATUS(x) \
88 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
89
90#define IS_WDI_STATUS_FAILURE(status) \
91 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]92#define CONVERT_WDI2VOS_STATUS(x) \
93 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
94
95/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]96#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]97#define WDA_TL_GET_TX_PKTCOUNT(a, b, c, d) WLANTL_GetTxPktCount(a, b, c, d)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#define WDA_GET_BA_TXFLAG(a, b, c) \
99 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
100
101#define WDA_SET_BA_TXFLAG(a, b, c) \
102 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
103
104#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
105 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]106#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
107 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]108/* timer related Macros */
109#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
110 tx_timer_create(a, b, c, d, e, f, g)
111#define WDA_START_TIMER(a) tx_timer_activate(a)
112#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
113#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]114#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]115
116#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
117 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]118#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]122#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]123
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]124#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]125
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]126#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]127#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
128 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
129 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
130
131#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
132#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]133#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
134
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]135/* extern declarations */
136extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]137extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]139/* forward declarations */
140void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
141 void *pBodyptr, tANI_U32 bodyVal) ;
142VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
143 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]144VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
145VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
146
147extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
148 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]149void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]150void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
151 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
152void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
153 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
154void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
155 void* pUserData ) ;
156static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
157static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
158void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]159void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]160void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161#ifdef WLAN_FEATURE_VOWIFI_11R
162VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
163#endif /* WLAN_FEATURE_VOWIFI_11R */
164
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]165void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
166void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
167VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]168#ifdef FEATURE_WLAN_SCAN_PNO
169static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
170static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
171static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
172#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]173#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]174VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]175void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
176void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
177void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
178#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]179#ifdef WLAN_FEATURE_PACKET_FILTERING
180static VOS_STATUS WDA_Process8023MulticastListReq (
181 tWDA_CbContext *pWDA,
182 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
183 );
184static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
185 tWDA_CbContext *pWDA,
186 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
187 );
188static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
189 tWDA_CbContext *pWDA,
190 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
191 );
192static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
193 tWDA_CbContext *pWDA,
194 tSirRcvFltPktClearParam *pRcvFltPktClearParam
195 );
196#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]197VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
199 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]200VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
201 v_U8_t *pDefaultKeyId,
202 v_U8_t *pNumKeys,
203 WDI_KeysType *pWdiKeys );
204
205#ifdef WLAN_FEATURE_GTK_OFFLOAD
206static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
207static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
208#endif // WLAN_FEATURE_GTK_OFFLOAD
209
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]210v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
211 tSirBcnMissRateReq *pData);
212
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]213VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
214 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]215#ifdef WLAN_FEATURE_11AC
216VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
217 tUpdateVHTOpMode *pData);
218#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]219
220#ifdef FEATURE_WLAN_LPHB
221VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
222 tSirLPHBReq *pData);
223#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]224
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]225#ifdef WLAN_FEATURE_EXTSCAN
226VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
227 tSirEXTScanStartReqParams *wdaRequest);
228VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
229 tSirEXTScanStopReqParams *wdaRequest);
230VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
231 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
232VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
233 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
234VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
235 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
236VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
237 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
238VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
239 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
240VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
241 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
242#endif /* WLAN_FEATURE_EXTSCAN */
243
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]244#ifdef WLAN_FEATURE_LINK_LAYER_STATS
245VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
246 tSirLLStatsSetReq *wdaRequest);
247
248VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
249 tSirLLStatsGetReq *wdaRequest);
250
251VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
252 tSirLLStatsClearReq *wdaRequest);
253#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]254/*
255 * FUNCTION: WDA_open
256 * Allocate the WDA context
257 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]258VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]259 tMacOpenParameters *pMacParams )
260{
261 tWDA_CbContext *wdaContext;
262 VOS_STATUS status;
263 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]264 /* Allocate WDA context */
265 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
266 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
267 if(!VOS_IS_STATUS_SUCCESS(status))
268 {
269 return VOS_STATUS_E_NOMEM;
270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]271 /*__asm int 3;*/
272 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
273
274 /* Initialize data structures */
275 wdaContext->pVosContext = pVosContext;
276 wdaContext->wdaState = WDA_INIT_STATE;
277 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
278
279 /* Initialize WDA-WDI synchronization event */
280 status = vos_event_init(&wdaContext->wdaWdiEvent);
281 if(!VOS_IS_STATUS_SUCCESS(status))
282 {
283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]284 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]285 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]286 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 /* Init Frame transfer event */
288 status = vos_event_init(&wdaContext->txFrameEvent);
289 if(!VOS_IS_STATUS_SUCCESS(status))
290 {
291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]292 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]293 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]294 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 status = vos_event_init(&wdaContext->suspendDataTxEvent);
296 if(!VOS_IS_STATUS_SUCCESS(status))
297 {
298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]299 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]300 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]301 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
303 if(!VOS_IS_STATUS_SUCCESS(status))
304 {
305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]306 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]307 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]308 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]311 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]312 &wdiDevCapability, pMacParams->driverType))
313 {
314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
315 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]316 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]317 }
318 else
319 {
320 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
321 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
322 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]323 /* update max STA in WDA used for BA */
324 wdaContext->wdaMaxSta = pMacParams->maxStation;
325 /* store the frameTransRequired flag in wdaContext, to send this to HAL
326 * in WDA_Start
327 */
328 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
329 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]330 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]331
332error:
333 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
334 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]335}
336
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]337/*
338 * FUNCTION: WDA_preStart
339 * Trigger DAL-AL to start CFG download
340 */
341VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
342{
343 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
344 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]345 /*
346 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
347 */
348 wdaMsg.type = WNI_CFG_DNLD_REQ ;
349 wdaMsg.bodyptr = NULL;
350 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]351 /* post the message.. */
352 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
353 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
354 {
355 vosStatus = VOS_STATUS_E_BADMSG;
356 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]357 return( vosStatus );
358}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]359/*
360 * FUNCTION: WDA_wdiStartCallback
361 * Once WDI_Start is finished, WDI start callback will be called by WDI
362 * to indicate completion of WDI_Start.
363 */
364void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
365 void *pVosContext)
366{
367 tWDA_CbContext *wdaContext;
368 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]369 if (NULL == pVosContext)
370 {
371 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]372 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]373 return;
374 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]375 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
376 if (NULL == wdaContext)
377 {
378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]379 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]380 return;
381 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]382 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
383 {
384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]385 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]386 }
387 else
388 {
389 wdaContext->wdaState = WDA_START_STATE;
390 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]391 /* extract and save version information from the Start Response */
392 wdaContext->wcnssWlanCompiledVersion.major =
393 wdiRspParams->wlanCompiledVersion.major;
394 wdaContext->wcnssWlanCompiledVersion.minor =
395 wdiRspParams->wlanCompiledVersion.minor;
396 wdaContext->wcnssWlanCompiledVersion.version =
397 wdiRspParams->wlanCompiledVersion.version;
398 wdaContext->wcnssWlanCompiledVersion.revision =
399 wdiRspParams->wlanCompiledVersion.revision;
400 wdaContext->wcnssWlanReportedVersion.major =
401 wdiRspParams->wlanReportedVersion.major;
402 wdaContext->wcnssWlanReportedVersion.minor =
403 wdiRspParams->wlanReportedVersion.minor;
404 wdaContext->wcnssWlanReportedVersion.version =
405 wdiRspParams->wlanReportedVersion.version;
406 wdaContext->wcnssWlanReportedVersion.revision =
407 wdiRspParams->wlanReportedVersion.revision;
408 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
409 wdiRspParams->wcnssSoftwareVersion,
410 sizeof(wdaContext->wcnssSoftwareVersionString));
411 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
412 wdiRspParams->wcnssHardwareVersion,
413 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]414 /* Notify WDA_start that WDI_Start has completed */
415 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]416 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]417 {
418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]419 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]420 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 return;
422}
423
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]424/*
425 * FUNCTION: WDA_start
426 * Prepare TLV configuration and call WDI_Start.
427 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]428VOS_STATUS WDA_start(v_PVOID_t pVosContext)
429{
430 tWDA_CbContext *wdaContext;
431 VOS_STATUS status;
432 WDI_Status wdiStatus;
433 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]434 if (NULL == pVosContext)
435 {
436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]437 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]438 return VOS_STATUS_E_FAILURE;
439 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]440 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
441 if (NULL == wdaContext)
442 {
443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]444 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]445 return VOS_STATUS_E_FAILURE;
446 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]447 /* Non-FTM mode, WDA status for START must be INIT
448 * FTM mode, WDA Status for START can be INIT or STOP */
449 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
450 (WDA_STOP_STATE != wdaContext->wdaState) )
451 {
452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
453 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]454 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]455 return VOS_STATUS_E_FAILURE;
456 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]457 /* initialize the wdiStartParam. Note that we can create this on
458 the stack since we won't exit until WDI_Start() completes or
459 times out */
460 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]461 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 /* prepare the config TLV for the WDI */
463 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
464 if ( !VOS_IS_STATUS_SUCCESS(status) )
465 {
466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]467 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]468 return VOS_STATUS_E_FAILURE;
469 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]470 /* note from here onwards if an error occurs we must
471 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]472 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
473 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
474 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]475 /* initialize the WDA-WDI synchronization event */
476 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]477 /* call WDI start */
478 wdiStatus = WDI_Start(&wdiStartParam,
479 (WDI_StartRspCb)WDA_wdiStartCallback,
480 (v_VOID_t *)pVosContext);
481 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
482 {
483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]484 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]485 vos_mem_free(wdiStartParam.pConfigBuffer);
486 return VOS_STATUS_E_FAILURE;
487 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]488 /* wait for WDI start to invoke our callback */
489 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
490 WDA_WDI_START_TIMEOUT );
491 if ( !VOS_IS_STATUS_SUCCESS(status) )
492 {
493 if ( VOS_STATUS_E_TIMEOUT == status )
494 {
495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]496 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]497 }
498 else
499 {
500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
501 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]502 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]503 }
504 vos_mem_free(wdiStartParam.pConfigBuffer);
505 return VOS_STATUS_E_FAILURE;
506 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]507 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* we no longer need the config TLV */
509 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]510 /* if we are not in the START state then WDI_Start() failed */
511 if (WDA_START_STATE != wdaContext->wdaState)
512 {
513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]514 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]515 return VOS_STATUS_E_FAILURE;
516 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]517 /* FTM mode does not need to monitor BA activity */
518 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
519 {
520 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]521 if(VOS_STATUS_SUCCESS == status)
522 {
523 wdaContext->wdaTimersCreated = VOS_TRUE;
524 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]525 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]526 else
527 {
528 vos_event_init(&wdaContext->ftmStopDoneEvent);
529 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]530 return status;
531}
532
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]533/*
534 * FUNCTION: WDA_prepareConfigTLV
535 * Function to prepare CFG for DAL(WDA)
536 */
537VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
538 WDI_StartReqParamsType *wdiStartParams )
539{
540 /* get pMac to acess CFG data base */
541 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
542 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
543 tHalCfg *tlvStruct = NULL ;
544 tANI_U8 *tlvStructStart = NULL ;
545 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
546 v_PVOID_t *configParam;
547 tANI_U32 configParamSize;
548 tANI_U32 *configDataValue;
549 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]550 tANI_U8 i;
551
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]552 if ((NULL == pMac)||(NULL == wdaContext))
553 {
554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]555 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]556 VOS_ASSERT(0);
557 return VOS_STATUS_E_FAILURE;
558 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]559 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
560 WNI_CFG_STA_ID_LEN +
561 WNI_CFG_EDCA_WME_ACBK_LEN +
562 WNI_CFG_EDCA_WME_ACBE_LEN +
563 WNI_CFG_EDCA_WME_ACVI_LEN +
564 WNI_CFG_EDCA_WME_ACVO_LEN +
565 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]566 /* malloc memory for all configs in one shot */
567 configParam = vos_mem_malloc(configParamSize);
568
569 if(NULL == configParam )
570 {
571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]572 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]573 VOS_ASSERT(0) ;
574 return VOS_STATUS_E_NOMEM;
575 }
576 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]577 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 tlvStruct = (tHalCfg *)configParam;
579 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]580 /* TODO: Remove Later */
581 /* QWLAN_HAL_CFG_STA_ID */
582 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
583 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
584 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
585 eSIR_SUCCESS)
586 {
587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
588 "Failed to get value for WNI_CFG_STA_ID");
589 goto handle_failure;
590 }
591 tlvStruct->length = strLength ;
592 /* calculate the pad bytes to have the CFG in aligned format */
593 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
594 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]595 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
596 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]597 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
598 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
599 tlvStruct->length = sizeof(tANI_U32);
600 configDataValue = (tANI_U32 *)(tlvStruct + 1);
601 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
602 != eSIR_SUCCESS)
603 {
604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
605 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
606 goto handle_failure;
607 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]608 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
609 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]610 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
611 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
612 tlvStruct->length = sizeof(tANI_U32);
613 configDataValue = (tANI_U32 *)(tlvStruct + 1);
614 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
615 eSIR_SUCCESS)
616 {
617 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
618 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
619 goto handle_failure;
620 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]621 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
622 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]623 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
624 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
625 tlvStruct->length = sizeof(tANI_U32);
626 configDataValue = (tANI_U32 *)(tlvStruct + 1);
627 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
628 != eSIR_SUCCESS)
629 {
630 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
631 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
632 goto handle_failure;
633 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]634 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
635 + sizeof(tHalCfg) + tlvStruct->length)) ;
636
637 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
638 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
639 tlvStruct->length = sizeof(tANI_U32);
640 configDataValue = (tANI_U32 *)(tlvStruct + 1);
641 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
642 configDataValue ) != eSIR_SUCCESS)
643 {
644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
645 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
646 goto handle_failure;
647 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]648 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
649 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]650 /* QWLAN_HAL_CFG_CAL_PERIOD */
651 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
652 tlvStruct->length = sizeof(tANI_U32);
653 configDataValue = (tANI_U32 *)(tlvStruct + 1);
654 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
655 != eSIR_SUCCESS)
656 {
657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
658 "Failed to get value for WNI_CFG_CAL_PERIOD");
659 goto handle_failure;
660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]661 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
662 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]663 /* QWLAN_HAL_CFG_CAL_CONTROL */
664 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
665 tlvStruct->length = sizeof(tANI_U32);
666 configDataValue = (tANI_U32 *)(tlvStruct + 1);
667 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
668 != eSIR_SUCCESS)
669 {
670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
671 "Failed to get value for WNI_CFG_CAL_CONTROL");
672 goto handle_failure;
673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]674 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
675 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]676 /* QWLAN_HAL_CFG_PROXIMITY */
677 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
678 tlvStruct->length = sizeof(tANI_U32);
679 configDataValue = (tANI_U32 *)(tlvStruct + 1);
680 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
681 != eSIR_SUCCESS)
682 {
683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
684 "Failed to get value for WNI_CFG_PROXIMITY");
685 goto handle_failure;
686 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]687 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
688 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]689 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
690 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
691 tlvStruct->length = sizeof(tANI_U32);
692 configDataValue = (tANI_U32 *)(tlvStruct + 1);
693 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
694 != eSIR_SUCCESS)
695 {
696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
697 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
698 goto handle_failure;
699 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]700 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
701 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]702 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
703 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
704 tlvStruct->length = sizeof(tANI_U32);
705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
706 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
707 eSIR_SUCCESS)
708 {
709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
710 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
711 goto handle_failure;
712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]713 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
714 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]715 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
716 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
717 tlvStruct->length = sizeof(tANI_U32);
718 configDataValue = (tANI_U32 *)(tlvStruct + 1);
719 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
720 configDataValue ) != eSIR_SUCCESS)
721 {
722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
723 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
724 goto handle_failure;
725 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]726 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
727 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]728 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
729 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
730 tlvStruct->length = sizeof(tANI_U32);
731 configDataValue = (tANI_U32 *)(tlvStruct + 1);
732 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
733 eSIR_SUCCESS)
734 {
735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
736 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
737 goto handle_failure;
738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]739 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
740 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]741 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
742 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
743 tlvStruct->length = sizeof(tANI_U32);
744 configDataValue = (tANI_U32 *)(tlvStruct + 1);
745 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
746 eSIR_SUCCESS)
747 {
748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
749 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
750 goto handle_failure;
751 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]752 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
753 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]754 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
755 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
756 tlvStruct->length = sizeof(tANI_U32);
757 configDataValue = (tANI_U32 *)(tlvStruct + 1);
758 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
759 eSIR_SUCCESS)
760 {
761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
762 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
763 goto handle_failure;
764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]765 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
766 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]767 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
768 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
769 tlvStruct->length = sizeof(tANI_U32);
770 configDataValue = (tANI_U32 *)(tlvStruct + 1);
771 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
772 configDataValue ) != eSIR_SUCCESS)
773 {
774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
775 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
776 goto handle_failure;
777 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]778 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
779 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]780 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
781 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
782 tlvStruct->length = sizeof(tANI_U32);
783 configDataValue = (tANI_U32 *)(tlvStruct + 1);
784 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
785 configDataValue ) != eSIR_SUCCESS)
786 {
787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
788 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
789 goto handle_failure;
790 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]791 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
792 + sizeof(tHalCfg) + tlvStruct->length));
793
794 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
795 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
796 tlvStruct->length = sizeof(tANI_U32);
797 configDataValue = (tANI_U32 *)(tlvStruct + 1);
798 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
799 configDataValue ) != eSIR_SUCCESS)
800 {
801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
802 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
803 goto handle_failure;
804 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]805 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
806 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]807 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
808 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
809 tlvStruct->length = sizeof(tANI_U32);
810 configDataValue = (tANI_U32 *)(tlvStruct + 1);
811 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
812 configDataValue ) != eSIR_SUCCESS)
813 {
814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
815 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
816 goto handle_failure;
817 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]818 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
819 + sizeof(tHalCfg) + tlvStruct->length));
820
821 /* QWLAN_HAL_CFG_FIXED_RATE */
822 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
823 tlvStruct->length = sizeof(tANI_U32);
824 configDataValue = (tANI_U32 *)(tlvStruct + 1);
825 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
826 != eSIR_SUCCESS)
827 {
828 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
829 "Failed to get value for WNI_CFG_FIXED_RATE");
830 goto handle_failure;
831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]832 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
833 + sizeof(tHalCfg) + tlvStruct->length));
834
835 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
836 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
837 tlvStruct->length = sizeof(tANI_U32);
838 configDataValue = (tANI_U32 *)(tlvStruct + 1);
839 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
840 != eSIR_SUCCESS)
841 {
842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
843 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
844 goto handle_failure;
845 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]846 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
847 + sizeof(tHalCfg) + tlvStruct->length));
848
849 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
850 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
851 tlvStruct->length = sizeof(tANI_U32);
852 configDataValue = (tANI_U32 *)(tlvStruct + 1);
853 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
854 configDataValue ) != eSIR_SUCCESS)
855 {
856 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
857 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
858 goto handle_failure;
859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]860 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
861 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]862 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
863 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
864 tlvStruct->length = sizeof(tANI_U32);
865 configDataValue = (tANI_U32 *)(tlvStruct + 1);
866 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
867 configDataValue ) != eSIR_SUCCESS)
868 {
869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
870 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
871 goto handle_failure;
872 }
873 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
874 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]875 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
876 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
877 tlvStruct->length = sizeof(tANI_U32);
878 configDataValue = (tANI_U32 *)(tlvStruct + 1);
879 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
880 configDataValue ) != eSIR_SUCCESS)
881 {
882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
883 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
884 goto handle_failure;
885 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]886 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
887 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]888 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
889 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
890 tlvStruct->length = sizeof(tANI_U32);
891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
892 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
893 configDataValue ) != eSIR_SUCCESS)
894 {
895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
896 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
897 goto handle_failure;
898 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]899 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
900 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]901 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
902 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
903 tlvStruct->length = sizeof(tANI_U32);
904 configDataValue = (tANI_U32 *)(tlvStruct + 1);
905 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
906 configDataValue ) != eSIR_SUCCESS)
907 {
908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
909 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
910 goto handle_failure;
911 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]912 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
913 + sizeof(tHalCfg) + tlvStruct->length);
914
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]915 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
916 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
917 tlvStruct->length = sizeof(tANI_U32);
918 configDataValue = (tANI_U32 *)(tlvStruct + 1);
919 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
920 configDataValue ) != eSIR_SUCCESS)
921 {
922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
923 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
924 goto handle_failure;
925 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]926 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
927 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]928 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
929 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
930 tlvStruct->length = sizeof(tANI_U32);
931 configDataValue = (tANI_U32 *)(tlvStruct + 1);
932 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
933 configDataValue ) != eSIR_SUCCESS)
934 {
935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
936 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
937 goto handle_failure;
938 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]939 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
940 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]941 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
942 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
943 tlvStruct->length = sizeof(tANI_U32);
944 configDataValue = (tANI_U32 *)(tlvStruct + 1);
945 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
946 eSIR_SUCCESS)
947 {
948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
949 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
950 goto handle_failure;
951 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]952 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
953 + sizeof(tHalCfg) + tlvStruct->length);
954
955 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
956 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
957 tlvStruct->length = sizeof(tANI_U32);
958 configDataValue = (tANI_U32 *)(tlvStruct + 1);
959 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
960 configDataValue ) != eSIR_SUCCESS)
961 {
962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
963 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
964 goto handle_failure;
965 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]966 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
967 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]968 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
969 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
970 tlvStruct->length = sizeof(tANI_U32);
971 configDataValue = (tANI_U32 *)(tlvStruct + 1);
972 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
973 configDataValue ) != eSIR_SUCCESS)
974 {
975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
976 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
977 goto handle_failure;
978 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]979 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
980 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]981 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
982 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
983 tlvStruct->length = sizeof(tANI_U32);
984 configDataValue = (tANI_U32 *)(tlvStruct + 1);
985 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
986 configDataValue ) != eSIR_SUCCESS)
987 {
988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
989 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
990 goto handle_failure;
991 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]992 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
993 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]994 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
995 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
996 tlvStruct->length = sizeof(tANI_U32);
997 configDataValue = (tANI_U32 *)(tlvStruct + 1);
998 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
999 configDataValue ) != eSIR_SUCCESS)
1000 {
1001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1002 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1003 goto handle_failure;
1004 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1005 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1006 + sizeof(tHalCfg) + tlvStruct->length);
1007
1008 /* QWLAN_HAL_CFG_STATS_PERIOD */
1009 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1010 tlvStruct->length = sizeof(tANI_U32);
1011 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1012 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1013 eSIR_SUCCESS)
1014 {
1015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1016 "Failed to get value for WNI_CFG_STATS_PERIOD");
1017 goto handle_failure;
1018 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1019 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1020 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1021 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1022 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1023 tlvStruct->length = sizeof(tANI_U32);
1024 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1025 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1026 eSIR_SUCCESS)
1027 {
1028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1029 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1030 goto handle_failure;
1031 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1032 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1033 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1034 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1035 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1036 tlvStruct->length = sizeof(tANI_U32);
1037 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1038 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1039 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1040 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1041 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1042 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1043 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1044 tlvStruct->length = sizeof(tANI_U32);
1045 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1046 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1047 != eSIR_SUCCESS)
1048 {
1049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1050 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1051 goto handle_failure;
1052 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1053 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1054 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1055 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1056 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1057 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1058 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1059 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1060 &strLength) != eSIR_SUCCESS)
1061 {
1062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1063 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1064 goto handle_failure;
1065 }
1066 tlvStruct->length = strLength;
1067 /* calculate the pad bytes to have the CFG in aligned format */
1068 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1069 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1070 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1071 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1072 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1073 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1074 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1075 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1076 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1077 &strLength) != eSIR_SUCCESS)
1078 {
1079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1080 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1081 goto handle_failure;
1082 }
1083 tlvStruct->length = strLength;
1084 /* calculate the pad bytes to have the CFG in aligned format */
1085 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1086 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1087 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1088 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1089 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1090 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1091 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1092 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1093 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1094 &strLength) != eSIR_SUCCESS)
1095 {
1096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1097 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1098 goto handle_failure;
1099 }
1100 tlvStruct->length = strLength;
1101 /* calculate the pad bytes to have the CFG in aligned format */
1102 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1103 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1104 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1105 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1106 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1107 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1108 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1109 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1110 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1111 &strLength) != eSIR_SUCCESS)
1112 {
1113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1114 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1115 goto handle_failure;
1116 }
1117 tlvStruct->length = strLength;
1118 /* calculate the pad bytes to have the CFG in aligned format */
1119 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1120 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1121 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1122 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1123 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1124 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1125 tlvStruct->length = sizeof(tANI_U32);
1126 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1127 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1128 != eSIR_SUCCESS)
1129 {
1130 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1131 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1132 goto handle_failure;
1133 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1134 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1135 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1136 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1137 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1138 tlvStruct->length = sizeof(tANI_U32);
1139 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1140 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1141 != eSIR_SUCCESS)
1142 {
1143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1144 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1145 goto handle_failure;
1146 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1147 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1148 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1149 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1150 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1151 tlvStruct->length = sizeof(tANI_U32);
1152 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1153 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1154 != eSIR_SUCCESS)
1155 {
1156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1157 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1158 goto handle_failure;
1159 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1160 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1161 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1162 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1163 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1164 tlvStruct->length = sizeof(tANI_U32);
1165 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1166 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1167 != eSIR_SUCCESS)
1168 {
1169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1170 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1171 goto handle_failure;
1172 }
1173 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1174 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1175 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1176 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1177 tlvStruct->length = sizeof(tANI_U32);
1178 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1179 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1180 != eSIR_SUCCESS)
1181 {
1182 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1183 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1184 goto handle_failure;
1185 }
1186 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1187 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1188 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1189 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1190 tlvStruct->length = sizeof(tANI_U32);
1191 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1192 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1193 != eSIR_SUCCESS)
1194 {
1195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1196 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1197 goto handle_failure;
1198 }
1199 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1200 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1201 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1202 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1203 tlvStruct->length = sizeof(tANI_U32);
1204 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1205 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1206 != eSIR_SUCCESS)
1207 {
1208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1209 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1210 goto handle_failure;
1211 }
1212 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1213 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1214 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1215 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1216 tlvStruct->length = sizeof(tANI_U32);
1217 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1218 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1219 != eSIR_SUCCESS)
1220 {
1221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1222 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1223 goto handle_failure;
1224 }
1225 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1226 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1227 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1228 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1229 tlvStruct->length = sizeof(tANI_U32);
1230 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1231 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1232 != eSIR_SUCCESS)
1233 {
1234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1235 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1236 goto handle_failure;
1237 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1238 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1239 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1240 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1241 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1242 tlvStruct->length = sizeof(tANI_U32);
1243 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1244 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1245 != eSIR_SUCCESS)
1246 {
1247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1248 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1249 goto handle_failure;
1250 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1251 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1252 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1253 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1254 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1255 tlvStruct->length = sizeof(tANI_U32);
1256 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1257 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1258 != eSIR_SUCCESS)
1259 {
1260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1261 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1262 goto handle_failure;
1263 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1264 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1265 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1266 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1267 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1268 * into FW, so the parameters are added here.
1269 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1270 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1271 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1272 tlvStruct->length = sizeof(tANI_U32);
1273 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1274 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1275 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1276 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1277 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1278 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1279 tlvStruct->length = sizeof(tANI_U32);
1280 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1281 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1282 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1283 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1284 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1285 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1286 tlvStruct->length = sizeof(tANI_U32);
1287 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1288 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1289 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1290 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1291 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1292 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1293 tlvStruct->length = sizeof(tANI_U32);
1294 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1295 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1296 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1297 + sizeof(tHalCfg) + tlvStruct->length) ;
1298
1299 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1300 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1301 tlvStruct->length = sizeof(tANI_U32);
1302 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1303 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1304 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1305 + sizeof(tHalCfg) + tlvStruct->length) ;
1306
1307 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1308 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1309 tlvStruct->length = sizeof(tANI_U32);
1310 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1311 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1312 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1313 + sizeof(tHalCfg) + tlvStruct->length) ;
1314
1315 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1316 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1317 tlvStruct->length = sizeof(tANI_U32);
1318 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1319 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1320 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1321 + sizeof(tHalCfg) + tlvStruct->length) ;
1322
1323 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1324 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1325 tlvStruct->length = sizeof(tANI_U32);
1326 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1327 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1328 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1329 + sizeof(tHalCfg) + tlvStruct->length) ;
1330
1331 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1332 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1333 tlvStruct->length = sizeof(tANI_U32);
1334 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1335 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1336 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1337 + sizeof(tHalCfg) + tlvStruct->length) ;
1338
1339 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1340 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1341 tlvStruct->length = sizeof(tANI_U32);
1342 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1343 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1344 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1345 + sizeof(tHalCfg) + tlvStruct->length) ;
1346
1347 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1348 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1349 tlvStruct->length = sizeof(tANI_U32);
1350 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1351 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1352 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1353 + sizeof(tHalCfg) + tlvStruct->length) ;
1354
1355 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1356 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1357 tlvStruct->length = sizeof(tANI_U32);
1358 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1359 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1360 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1361 + sizeof(tHalCfg) + tlvStruct->length) ;
1362
1363 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1364 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1365 tlvStruct->length = sizeof(tANI_U32);
1366 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1367 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1368 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1369 + sizeof(tHalCfg) + tlvStruct->length) ;
1370
1371 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1372 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1373 tlvStruct->length = sizeof(tANI_U32);
1374 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1375 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1376 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1377 + sizeof(tHalCfg) + tlvStruct->length) ;
1378
1379 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1380 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1381 tlvStruct->length = sizeof(tANI_U32);
1382 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1383 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1384 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1385 + sizeof(tHalCfg) + tlvStruct->length) ;
1386
1387 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1388 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1389 tlvStruct->length = sizeof(tANI_U32);
1390 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1391 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1392 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1393 + sizeof(tHalCfg) + tlvStruct->length) ;
1394
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1395 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1396 {
1397 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1398 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1399 tlvStruct->length = sizeof(tANI_U32);
1400 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1401 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1402 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1403 + sizeof(tHalCfg) + tlvStruct->length) ;
1404
1405 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1406 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1407 tlvStruct->length = sizeof(tANI_U32);
1408 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1409 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1410 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1411 + sizeof(tHalCfg) + tlvStruct->length) ;
1412
1413 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1414 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1415 tlvStruct->length = sizeof(tANI_U32);
1416 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1417 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1418 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1419 + sizeof(tHalCfg) + tlvStruct->length) ;
1420
1421 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1422 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1423 tlvStruct->length = sizeof(tANI_U32);
1424 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1425 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1426 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1427 + sizeof(tHalCfg) + tlvStruct->length) ;
1428 }
1429
1430 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1431 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1432 tlvStruct->length = sizeof(tANI_U32);
1433 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1434 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1435 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1436 + sizeof(tHalCfg) + tlvStruct->length) ;
1437
1438 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1439 {
1440 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1441 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1442 tlvStruct->length = sizeof(tANI_U32);
1443 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1444 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1445 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1446 + sizeof(tHalCfg) + tlvStruct->length) ;
1447 }
1448
1449 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1450 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1451 tlvStruct->length = sizeof(tANI_U32);
1452 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1453 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1454 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1455 + sizeof(tHalCfg) + tlvStruct->length) ;
1456
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1457 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1458 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1459 tlvStruct->length = sizeof(tANI_U32);
1460 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1461 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1462 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1463 wcnssCompiledApiVersion.minor,
1464 wcnssCompiledApiVersion.version,
1465 wcnssCompiledApiVersion.revision);
1466 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1467 + sizeof(tHalCfg) + tlvStruct->length) ;
1468
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1469 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1470 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1471 tlvStruct->length = sizeof(tANI_U32);
1472 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1473 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1474 configDataValue ) != eSIR_SUCCESS)
1475 {
1476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1477 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1478 goto handle_failure;
1479 }
1480
1481 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1482 + sizeof(tHalCfg) + tlvStruct->length) ;
1483 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1484 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1485 tlvStruct->length = sizeof(tANI_U32);
1486 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1487 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1488 configDataValue ) != eSIR_SUCCESS)
1489 {
1490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1491 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1492 goto handle_failure;
1493 }
1494
1495 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1496 + sizeof(tHalCfg) + tlvStruct->length) ;
1497
1498 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1499 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1500 tlvStruct->length = sizeof(tANI_U32);
1501 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1502 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1503 != eSIR_SUCCESS)
1504 {
1505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1506 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1507 goto handle_failure;
1508 }
1509
1510 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1511 + sizeof(tHalCfg) + tlvStruct->length) ;
1512
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1513 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1514 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1515 tlvStruct->length = sizeof(tANI_U32);
1516 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1517 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1518 != eSIR_SUCCESS)
1519 {
1520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1521 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1522 goto handle_failure;
1523 }
1524
1525 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1526 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1527#ifdef WLAN_SOFTAP_VSTA_FEATURE
1528 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1529 tlvStruct->length = sizeof(tANI_U32);
1530 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1531 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1532 != eSIR_SUCCESS)
1533 {
1534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1535 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1536 goto handle_failure;
1537 }
1538
1539 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1540 + sizeof(tHalCfg) + tlvStruct->length) ;
1541#endif
1542
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1543 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1544 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1545 tlvStruct->length = sizeof(tANI_U32);
1546 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1547
1548 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1549 != eSIR_SUCCESS)
1550 {
1551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1552 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1553 goto handle_failure;
1554 }
1555
1556 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1557 + sizeof(tHalCfg) + tlvStruct->length) ;
1558
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1559/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1560 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1561 tlvStruct->length = sizeof(tANI_U32);
1562 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1563 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1564 configDataValue ) != eSIR_SUCCESS)
1565 {
1566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1567 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1568 goto handle_failure;
1569 }
1570
1571 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1572 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1573#ifdef FEATURE_WLAN_TDLS
1574 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1575 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1576 tlvStruct->length = sizeof(tANI_U32);
1577 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1578 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1579 configDataValue ) != eSIR_SUCCESS)
1580 {
1581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1582 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1583 goto handle_failure;
1584 }
1585 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1586 + sizeof(tHalCfg) + tlvStruct->length) ;
1587
1588 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1589 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1590 tlvStruct->length = sizeof(tANI_U32);
1591 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1592 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1593 configDataValue ) != eSIR_SUCCESS)
1594 {
1595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1596 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1597 goto handle_failure;
1598 }
1599 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1600 + sizeof(tHalCfg) + tlvStruct->length) ;
1601 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1602 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1603 tlvStruct->length = sizeof(tANI_U32);
1604 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1605 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1606 configDataValue ) != eSIR_SUCCESS)
1607 {
1608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1609 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1610 goto handle_failure;
1611 }
1612 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1613 + sizeof(tHalCfg) + tlvStruct->length) ;
1614 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1615 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1616 tlvStruct->length = sizeof(tANI_U32);
1617 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1618 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1619 configDataValue ) != eSIR_SUCCESS)
1620 {
1621 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1622 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1623 goto handle_failure;
1624 }
1625 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1626 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1627 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1628 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1629 tlvStruct->length = sizeof(tANI_U32);
1630 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1631 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1632 configDataValue ) != eSIR_SUCCESS)
1633 {
1634 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1635 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1636 goto handle_failure;
1637 }
1638 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1639 + sizeof(tHalCfg) + tlvStruct->length) ;
1640
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1641#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1642
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1643 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1644 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1645 tlvStruct->length = sizeof(tANI_U32);
1646 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1647 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1648 configDataValue ) != eSIR_SUCCESS)
1649 {
1650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1651 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1652 goto handle_failure;
1653 }
1654
1655 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1656 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1657
1658 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1659 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1660 tlvStruct->length = sizeof(tANI_U32);
1661 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1662 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1663 != eSIR_SUCCESS)
1664 {
1665 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1666 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1667 goto handle_failure;
1668 }
1669 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1670 + sizeof(tHalCfg) + tlvStruct->length));
1671
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1672 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1673 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1674 tlvStruct->length = sizeof(tANI_U32);
1675 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1676 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1677 configDataValue ) != eSIR_SUCCESS)
1678 {
1679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1680 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1681 goto handle_failure;
1682 }
1683
1684 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1685 + sizeof(tHalCfg) + tlvStruct->length) ;
1686
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1687 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1688 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1689 tlvStruct->length = sizeof(tANI_U32);
1690 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1691 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1692 configDataValue ) != eSIR_SUCCESS)
1693 {
1694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1695 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1696 goto handle_failure;
1697 }
1698 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1699 + sizeof(tHalCfg) + tlvStruct->length) ;
1700
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1701 /* QWLAN_HAL_CFG_ATH_DISABLE */
1702 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1703 tlvStruct->length = sizeof(tANI_U32);
1704 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1705 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1706 configDataValue ) != eSIR_SUCCESS)
1707 {
1708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1709 "Failed to get value for WNI_CFG_ATH_DISABLE");
1710 goto handle_failure;
1711 }
1712 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1713 + sizeof(tHalCfg) + tlvStruct->length) ;
1714
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1715 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1716 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1717 tlvStruct->length = sizeof(tANI_U32);
1718 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1719 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1720 configDataValue ) != eSIR_SUCCESS)
1721 {
1722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1723 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1724 goto handle_failure;
1725 }
1726 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1727 + sizeof(tHalCfg) + tlvStruct->length) ;
1728
1729 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1730 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1731 tlvStruct->length = sizeof(tANI_U32);
1732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1733 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1734 configDataValue ) != eSIR_SUCCESS)
1735 {
1736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1737 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1738 goto handle_failure;
1739 }
1740 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1741 + sizeof(tHalCfg) + tlvStruct->length) ;
1742
1743 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1744 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1745 tlvStruct->length = sizeof(tANI_U32);
1746 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1747 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1748 configDataValue ) != eSIR_SUCCESS)
1749 {
1750 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1751 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1752 goto handle_failure;
1753 }
1754 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1755 + sizeof(tHalCfg) + tlvStruct->length) ;
1756
1757 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1758 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1759 tlvStruct->length = sizeof(tANI_U32);
1760 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1761 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1762 configDataValue ) != eSIR_SUCCESS)
1763 {
1764 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1765 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1766 goto handle_failure;
1767 }
1768 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1769 + sizeof(tHalCfg) + tlvStruct->length) ;
1770
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1771 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1772 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1773 tlvStruct->length = sizeof(tANI_U32);
1774 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1775 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1776 configDataValue ) != eSIR_SUCCESS)
1777 {
1778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1779 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1780 goto handle_failure;
1781 }
1782 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1783 + sizeof(tHalCfg) + tlvStruct->length) ;
1784
1785 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1786 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1787 tlvStruct->length = sizeof(tANI_U32);
1788 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1789 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1790 configDataValue ) != eSIR_SUCCESS)
1791 {
1792 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1793 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1794 goto handle_failure;
1795 }
1796 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1797 + sizeof(tHalCfg) + tlvStruct->length) ;
1798
1799 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1800 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1801 tlvStruct->length = sizeof(tANI_U32);
1802 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1803 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1804 configDataValue ) != eSIR_SUCCESS)
1805 {
1806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1807 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1808 goto handle_failure;
1809 }
1810 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1811 + sizeof(tHalCfg) + tlvStruct->length) ;
1812
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1813 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1814 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1815 tlvStruct->length = sizeof(tANI_U32);
1816 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1817 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1818 configDataValue ) != eSIR_SUCCESS)
1819 {
1820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1821 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1822 goto handle_failure;
1823 }
1824 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1825 + sizeof(tHalCfg) + tlvStruct->length) ;
1826
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1827 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1828 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1829 tlvStruct->length = sizeof(tANI_U32);
1830 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1831
1832 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1833 configDataValue ) != eSIR_SUCCESS)
1834 {
1835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1836 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1837 goto handle_failure;
1838 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1839 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1840 + sizeof(tHalCfg) + tlvStruct->length) ;
1841
1842 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1843 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1844 tlvStruct->length = sizeof(tANI_U32);
1845 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1846
1847 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1848 configDataValue ) != eSIR_SUCCESS)
1849 {
1850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1851 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1852 goto handle_failure;
1853 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1854 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1855 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1856
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1857 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1858 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1859 tlvStruct->length = sizeof(tANI_U32);
1860 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1861
1862 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1863 configDataValue ) != eSIR_SUCCESS)
1864 {
1865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1866 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1867 goto handle_failure;
1868 }
1869 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1870 + sizeof(tHalCfg) + tlvStruct->length) ;
1871
1872 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1873 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1874 tlvStruct->length = sizeof(tANI_U32);
1875 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1876
1877 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1878 configDataValue ) != eSIR_SUCCESS)
1879 {
1880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1881 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1882 goto handle_failure;
1883 }
1884 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1885 + sizeof(tHalCfg) + tlvStruct->length) ;
1886
1887 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1888 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1889 tlvStruct->length = sizeof(tANI_U32);
1890 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1891
1892 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1893 configDataValue ) != eSIR_SUCCESS)
1894 {
1895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1896 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1897 goto handle_failure;
1898 }
1899 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1900 + sizeof(tHalCfg) + tlvStruct->length) ;
1901
1902 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1903 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1904 tlvStruct->length = sizeof(tANI_U32);
1905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1906
1907 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1908 configDataValue ) != eSIR_SUCCESS)
1909 {
1910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1911 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1912 goto handle_failure;
1913 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1914 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1915 + sizeof(tHalCfg) + tlvStruct->length) ;
1916
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1917 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1918#ifdef WLAN_DEBUG
1919 {
1920 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1921 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1922 "****** Dumping CFG TLV ***** ");
1923 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
1924 {
1925 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1926 "%02x %02x %02x %02x %02x %02x %02x %02x",
1927 tlvStructStart[i],
1928 tlvStructStart[i+1],
1929 tlvStructStart[i+2],
1930 tlvStructStart[i+3],
1931 tlvStructStart[i+4],
1932 tlvStructStart[i+5],
1933 tlvStructStart[i+6],
1934 tlvStructStart[i+7]);
1935 }
1936 /* Dump the bytes in the last line*/
1937 for (; i < wdiStartParams->usConfigBufferLen; i++)
1938 {
1939 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1940 "%02x ",tlvStructStart[i]);
1941 }
1942 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1943 "**************************** ");
1944 }
1945#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1946 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1947handle_failure:
1948 vos_mem_free(configParam);
1949 return VOS_STATUS_E_FAILURE;
1950}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1951/*
1952 * FUNCTION: WDA_wdiCompleteCB
1953 * call the voss call back function
1954 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1955void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1956{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1957 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
1958 tWDA_CbContext *wdaContext;
1959
1960 if(NULL == pWdaParams)
1961 {
1962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1963 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1964 VOS_ASSERT(0) ;
1965 return ;
1966 }
1967
1968 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
1969
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1970 if (NULL == wdaContext)
1971 {
1972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1973 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1974 return ;
1975 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1976
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1977 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1978 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1979 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1980 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1981 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1982 vos_mem_free(pWdaParams);
1983
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1984 if(WDI_STATUS_SUCCESS != status)
1985 {
1986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1987 "WDI stop callback returned failure" );
1988 VOS_ASSERT(0) ;
1989 }
1990 else
1991 {
1992 wdaContext->wdaState = WDA_STOP_STATE;
1993 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1994
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]1995 /* FTM Driver stop procedure should be synced.
1996 * Stop and Close will happen on same context */
1997 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
1998 {
1999 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2000 {
2001 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2002 "%s: FTM Stop Event Set Fail", __func__);
2003 VOS_ASSERT(0);
2004 }
2005 }
2006
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2007 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2008 vos_WDAComplete_cback(wdaContext->pVosContext);
2009
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2010 return ;
2011}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2012/*
2013 * FUNCTION: WDA_stop
2014 * call WDI_stop
2015 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2016VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2017{
2018 WDI_Status wdiStatus;
2019 VOS_STATUS status = VOS_STATUS_SUCCESS;
2020 WDI_StopReqParamsType *wdiStopReq;
2021 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2022 tWDA_ReqParams *pWdaParams ;
2023
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2024 if (NULL == pWDA)
2025 {
2026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2027 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2028 VOS_ASSERT(0);
2029 return VOS_STATUS_E_FAILURE;
2030 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2031 if (pWDA->wdiFailed == true)
2032 {
2033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2034 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2035 return VOS_STATUS_E_ALREADY;
2036 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2037
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2038 /* FTM mode stay START_STATE */
2039 if( (WDA_READY_STATE != pWDA->wdaState) &&
2040 (WDA_INIT_STATE != pWDA->wdaState) &&
2041 (WDA_START_STATE != pWDA->wdaState) )
2042 {
2043 VOS_ASSERT(0);
2044 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2045 wdiStopReq = (WDI_StopReqParamsType *)
2046 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2047 if(NULL == wdiStopReq)
2048 {
2049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2050 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2051 VOS_ASSERT(0);
2052 return VOS_STATUS_E_NOMEM;
2053 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2054
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2055 wdiStopReq->wdiStopReason = reason;
2056 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2057
2058 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2059 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2060 {
2061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2062 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2063 VOS_ASSERT(0);
2064 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2065 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2066 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2067
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2068 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2069 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2070 {
2071 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2072 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2073 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2074
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2075 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2076 pWdaParams->wdaMsgParam = NULL;
2077 pWdaParams->pWdaContext = pWDA;
2078
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2079 /* call WDI stop */
2080 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2081 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2082
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2083 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2084 {
2085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2086 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2087 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2088 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2089 status = VOS_STATUS_E_FAILURE;
2090 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2091
2092 /* FTM Driver stop procedure should be synced.
2093 * Stop and Close will happen on same context */
2094 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2095 {
2096 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2097 WDI_RESPONSE_TIMEOUT);
2098 if (status != VOS_STATUS_SUCCESS)
2099 {
2100 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2101 "%s: FTM Stop Timepoout", __func__);
2102 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2103 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame^]2104 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2105 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2106 return status;
2107}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2108/*
2109 * FUNCTION: WDA_close
2110 * call WDI_close and free the WDA context
2111 */
2112VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2113{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2114 VOS_STATUS status = VOS_STATUS_SUCCESS;
2115 WDI_Status wstatus;
2116 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2117 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2118 if (NULL == wdaContext)
2119 {
2120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2121 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2122 return VOS_STATUS_E_FAILURE;
2123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2124 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2125 (WDA_STOP_STATE != wdaContext->wdaState))
2126 {
2127 VOS_ASSERT(0);
2128 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2129 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2130 wstatus = WDI_Close();
2131 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2132 {
2133 status = VOS_STATUS_E_FAILURE;
2134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2135 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2136 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2137 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2138 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2139 {
2140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2141 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2142 status = VOS_STATUS_E_FAILURE;
2143 }
2144
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2145 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2146 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2147 {
2148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2149 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2150 status = VOS_STATUS_E_FAILURE;
2151 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2152 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2153 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2154 {
2155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2156 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2157 status = VOS_STATUS_E_FAILURE;
2158 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2159 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2160 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2161 {
2162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2163 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2164 status = VOS_STATUS_E_FAILURE;
2165 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2166 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2167 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2168 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2169 {
2170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2171 "error in WDA close " );
2172 status = VOS_STATUS_E_FAILURE;
2173 }
2174 return status;
2175}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2176/*
2177 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2178 * returns 1 if the compiled version is greater than or equal to the input version
2179 */
2180
2181uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2182{
2183 VOS_STATUS status = VOS_STATUS_SUCCESS;
2184 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2185 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2186 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2188 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2189 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2190 (compiledVersion.revision >= revision)))
2191 return 1;
2192 else
2193 return 0;
2194}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2195/*
2196 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2197 * returns 1 if the compiled version is greater than or equal to the input version
2198 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2200{
2201 VOS_STATUS status = VOS_STATUS_SUCCESS;
2202 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2203 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2204 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2205 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2206 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2207 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2208 (reportedVersion.revision >= revision)))
2209 return 1;
2210 else
2211 return 0;
2212}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2213/*
2214 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2215 * Returns the version of the WCNSS WLAN API with which the HOST
2216 * device driver was compiled
2217 */
2218VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2219 tSirVersionType *pVersion)
2220{
2221 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2222 if ((NULL == pvosGCtx) || (NULL == pVersion))
2223 {
2224 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2225 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2226 VOS_ASSERT(0);
2227 return VOS_STATUS_E_FAILURE;
2228 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2229 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2230 if (NULL == pWDA )
2231 {
2232 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2233 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2234 VOS_ASSERT(0);
2235 return VOS_STATUS_E_FAILURE;
2236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2237 *pVersion = pWDA->wcnssWlanCompiledVersion;
2238 return VOS_STATUS_SUCCESS;
2239}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2240/*
2241 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2242 * Returns the version of the WCNSS WLAN API with which the WCNSS
2243 * device driver was compiled
2244 */
2245VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2246 tSirVersionType *pVersion)
2247{
2248 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2249 if ((NULL == pvosGCtx) || (NULL == pVersion))
2250 {
2251 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2252 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2253 VOS_ASSERT(0);
2254 return VOS_STATUS_E_FAILURE;
2255 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2256 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2257 if (NULL == pWDA )
2258 {
2259 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2260 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2261 VOS_ASSERT(0);
2262 return VOS_STATUS_E_FAILURE;
2263 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2264 *pVersion = pWDA->wcnssWlanReportedVersion;
2265 return VOS_STATUS_SUCCESS;
2266}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2267/*
2268 * FUNCTION: WDA_GetWcnssSoftwareVersion
2269 * Returns the WCNSS Software version string
2270 */
2271VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2272 tANI_U8 *pVersion,
2273 tANI_U32 versionBufferSize)
2274{
2275 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2276 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2277 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2278 if ((NULL == pvosGCtx) || (NULL == pVersion))
2279 {
2280 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2281 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2282 VOS_ASSERT(0);
2283 return VOS_STATUS_E_FAILURE;
2284 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2285 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2286 if (NULL == pWDA )
2287 {
2288 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2289 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2290 VOS_ASSERT(0);
2291 return VOS_STATUS_E_FAILURE;
2292 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2293 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2294 return VOS_STATUS_SUCCESS;
2295}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2296/*
2297 * FUNCTION: WDA_GetWcnssHardwareVersion
2298 * Returns the WCNSS Hardware version string
2299 */
2300VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2301 tANI_U8 *pVersion,
2302 tANI_U32 versionBufferSize)
2303{
2304 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2305 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2306 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2307 if ((NULL == pvosGCtx) || (NULL == pVersion))
2308 {
2309 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2310 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2311 VOS_ASSERT(0);
2312 return VOS_STATUS_E_FAILURE;
2313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2314 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2315 if (NULL == pWDA )
2316 {
2317 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2318 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2319 VOS_ASSERT(0);
2320 return VOS_STATUS_E_FAILURE;
2321 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2322 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2323 return VOS_STATUS_SUCCESS;
2324}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2325/*
2326 * FUNCTION: WDA_WniCfgDnld
2327 * Trigger CFG Download
2328 */
2329VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2330{
2331 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2332 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2333
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2334 if (NULL == pMac )
2335 {
2336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2337 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2338 VOS_ASSERT(0);
2339 return VOS_STATUS_E_FAILURE;
2340 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2341 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2342 return vosStatus;
2343}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2344/* -----------------------------------------------------------------
2345 * WDI interface
2346 * -----------------------------------------------------------------
2347 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2348/*
2349 * FUNCTION: WDA_suspendDataTxCallback
2350 * call back function called from TL after suspend Transmission
2351 */
2352VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2353 v_U8_t* ucSTAId,
2354 VOS_STATUS vosStatus)
2355{
2356 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2358 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2359 if (NULL == pWDA )
2360 {
2361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2362 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2363 VOS_ASSERT(0);
2364 return VOS_STATUS_E_FAILURE;
2365 }
2366 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2367 {
2368 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2369 }
2370 else
2371 {
2372 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2373 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2374 /* Trigger the event to bring the WDA TL suspend function to come
2375 * out of wait*/
2376 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2377 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2378 {
2379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2380 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2381 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2382 /* If TL suspended had timedout before this callback was called, resume back
2383 * TL.*/
2384 if (pWDA->txSuspendTimedOut)
2385 {
2386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2387 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2388 WDA_ResumeDataTx(pWDA);
2389 pWDA->txSuspendTimedOut = FALSE;
2390 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2391 return VOS_STATUS_SUCCESS;
2392}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2393/*
2394 * FUNCTION: WDA_suspendDataTx
2395 * Update TL to suspend the data Transmission
2396 */
2397VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2398{
2399 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2400 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2401
2402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2403 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2404 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2405 if (pWDA->txSuspendTimedOut)
2406 {
2407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2408 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2409 return status;
2410 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2411 /* Reset the event to be not signalled */
2412 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2413 if(!VOS_IS_STATUS_SUCCESS(status))
2414 {
2415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2416 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2417 return VOS_STATUS_E_FAILURE;
2418 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2419 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2420 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 WDA_SuspendDataTxCallback);
2422 if(status != VOS_STATUS_SUCCESS)
2423 {
2424 return status;
2425 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2426 /* Wait for the event to be set by the TL, to get the response of
2427 * suspending the TX queues, this event should be set by the Callback
2428 * function called by TL*/
2429 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2430 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2431 if(!VOS_IS_STATUS_SUCCESS(status))
2432 {
2433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2434 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2435 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2436 /* Set this flag to true when TL suspend times out, so that when TL
2437 * suspend eventually happens and calls the callback, TL can be resumed
2438 * right away by looking at this flag when true.*/
2439 pWDA->txSuspendTimedOut = TRUE;
2440 }
2441 else
2442 {
2443 pWDA->txSuspendTimedOut = FALSE;
2444 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2445 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2446 {
2447 status = VOS_STATUS_SUCCESS;
2448 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2449 return status;
2450}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2451/*
2452 * FUNCTION: WDA_resumeDataTx
2453 * Update TL to resume the data Transmission
2454 */
2455VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2456{
2457 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458
2459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2460 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2461
2462 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2463 return status;
2464}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2465/*
2466 * FUNCTION: WDA_InitScanReqCallback
2467 * Trigger Init SCAN callback
2468 */
2469void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2470{
2471 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2472 tWDA_CbContext *pWDA;
2473 tInitScanParams *pWDA_ScanParam ;
2474 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2476 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2477 if(NULL == pWdaParams)
2478 {
2479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2480 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2481 VOS_ASSERT(0) ;
2482 return ;
2483 }
2484 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2485 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2486 if(NULL == pWDA_ScanParam)
2487 {
2488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2489 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2490 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2491 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2492 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2493 return ;
2494 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2495 if(WDI_STATUS_SUCCESS != wdiStatus)
2496 {
2497 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2498 if(VOS_STATUS_SUCCESS != status)
2499 {
2500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2501 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2502 }
2503 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2504 /* free WDI command buffer */
2505 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2506 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2507
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2508
2509 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2510 /* without converting the Status to Failure or Success Just
2511 pass the same status to lim */
2512 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2513 /* send SCAN RSP message back to PE */
2514 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2515 return ;
2516}
2517
2518/*
2519 * FUNCTION: WDA_ProcessInitScanReq
2520 * Trigger Init SCAN in DAL
2521 */
2522VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2523 tInitScanParams *initScanParams)
2524{
2525 WDI_Status status = WDI_STATUS_SUCCESS ;
2526 WDI_InitScanReqParamsType *wdiInitScanParam =
2527 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2528 sizeof(WDI_InitScanReqParamsType)) ;
2529 tWDA_ReqParams *pWdaParams;
2530 tANI_U8 i = 0;
2531
2532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2533 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2534 if(NULL == wdiInitScanParam)
2535 {
2536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2537 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2538 VOS_ASSERT(0);
2539 return VOS_STATUS_E_NOMEM;
2540 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2542 if(NULL == pWdaParams)
2543 {
2544 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2545 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2546 VOS_ASSERT(0);
2547 vos_mem_free(wdiInitScanParam);
2548 return VOS_STATUS_E_NOMEM;
2549 }
2550
2551 /* Copy init Scan params to WDI structure */
2552 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2553 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2554 sizeof(tSirMacAddr)) ;
2555 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2556 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2557 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2558 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2559 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2560 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2561 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2562 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2563 {
2564 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2565 initScanParams->scanEntry.bssIdx[i] ;
2566 }
2567
2568 /* if Frame length, copy macMgmtHdr or WDI structure */
2569 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2570 {
2571 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2572 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2573 }
2574 wdiInitScanParam->wdiReqStatusCB = NULL ;
2575
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2576 /* Store Init Req pointer, as this will be used for response */
2577 pWdaParams->pWdaContext = pWDA;
2578 pWdaParams->wdaMsgParam = initScanParams;
2579 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2580 /* first try to suspend TX */
2581 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2582 if(WDI_STATUS_SUCCESS != status)
2583 {
2584 goto handleWdiFailure;
2585 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2586 /* call DAL API to pass init scan request to DAL */
2587 status = WDI_InitScanReq(wdiInitScanParam,
2588 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2589 if(IS_WDI_STATUS_FAILURE(status))
2590 {
2591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2592 "error in WDA Init Scan, Resume Tx " );
2593 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2594 VOS_ASSERT(0) ;
2595
2596 goto handleWdiFailure;
2597 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2598 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599handleWdiFailure:
2600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2601 "Failure in WDI Api, free all the memory " );
2602 /* free WDI command buffer */
2603 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2604 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2605 /* send Failure to PE */
2606 initScanParams->status = eSIR_FAILURE ;
2607 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2608 return CONVERT_WDI2VOS_STATUS(status) ;
2609}
2610
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611/*
2612 * FUNCTION: WDA_StartScanReqCallback
2613 * send Start SCAN RSP back to PE
2614 */
2615void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2616 void* pUserData)
2617{
2618 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2619 tWDA_CbContext *pWDA;
2620 tStartScanParams *pWDA_ScanParam;
2621 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2622 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2623 if(NULL == pWdaParams)
2624 {
2625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2626 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2627 VOS_ASSERT(0) ;
2628 return ;
2629 }
2630 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2631 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2632 if(NULL == pWDA_ScanParam)
2633 {
2634 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2635 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2636 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2637 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2638 return ;
2639 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2640 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2641 {
2642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2643 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2644 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2645 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2646 return ;
2647 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2648 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2649 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2650
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651
2652 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2653 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2654 /* send SCAN RSP message back to PE */
2655 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2656 return ;
2657}
2658
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2659/*
2660 * FUNCTION: WDA_ProcessStartScanReq
2661 * Trigger start SCAN in WDI
2662 */
2663VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2664 tStartScanParams *startScanParams)
2665{
2666 WDI_Status status = WDI_STATUS_SUCCESS;
2667 WDI_StartScanReqParamsType *wdiStartScanParams =
2668 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2669 sizeof(WDI_StartScanReqParamsType)) ;
2670 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2672 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2673 if(NULL == wdiStartScanParams)
2674 {
2675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2676 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2677 VOS_ASSERT(0);
2678 return VOS_STATUS_E_NOMEM;
2679 }
2680 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2681 if(NULL == pWdaParams)
2682 {
2683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2684 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2685 VOS_ASSERT(0);
2686 vos_mem_free(wdiStartScanParams);
2687 return VOS_STATUS_E_NOMEM;
2688 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2689 /* Copy init Scan params to WDI structure */
2690 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2691 wdiStartScanParams->wdiReqStatusCB = NULL ;
2692
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2693 /* Store Init Req pointer, as this will be used for response */
2694 /* store Params pass it to WDI */
2695 pWdaParams->pWdaContext = pWDA;
2696 pWdaParams->wdaMsgParam = startScanParams;
2697 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2698 /* call DAL API to pass init scan request to DAL */
2699 status = WDI_StartScanReq(wdiStartScanParams,
2700 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2701 /* failure returned by WDI API */
2702 if(IS_WDI_STATUS_FAILURE(status))
2703 {
2704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2705 "Failure in Start Scan WDI API, free all the memory "
2706 "It should be due to previous abort scan." );
2707 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2708 vos_mem_free(pWdaParams) ;
2709 startScanParams->status = eSIR_FAILURE ;
2710 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2711 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2712 return CONVERT_WDI2VOS_STATUS(status) ;
2713}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2714/*
2715 * FUNCTION: WDA_EndScanReqCallback
2716 * END SCAN callback
2717 */
2718void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2719{
2720 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2721 tWDA_CbContext *pWDA;
2722 tEndScanParams *endScanParam;
2723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2724 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 if(NULL == pWdaParams)
2726 {
2727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2728 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2729 VOS_ASSERT(0) ;
2730 return ;
2731 }
2732 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2733 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2734 if(NULL == endScanParam)
2735 {
2736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2737 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2738 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2740 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2741 return ;
2742 }
2743
2744 /* Free WDI command buffer */
2745 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2746 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2748 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2749 /* send response back to PE */
2750 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2751 return ;
2752}
2753
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2754/*
2755 * FUNCTION: WDA_ProcessEndScanReq
2756 * Trigger END SCAN in WDI
2757 */
2758VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2759 tEndScanParams *endScanParams)
2760{
2761 WDI_Status status = WDI_STATUS_SUCCESS;
2762 WDI_EndScanReqParamsType *wdiEndScanParams =
2763 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2764 sizeof(WDI_EndScanReqParamsType)) ;
2765 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2767 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 if(NULL == wdiEndScanParams)
2769 {
2770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2771 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2772 VOS_ASSERT(0);
2773 return VOS_STATUS_E_NOMEM;
2774 }
2775 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2776 if(NULL == pWdaParams)
2777 {
2778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2779 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2780 VOS_ASSERT(0);
2781 vos_mem_free(wdiEndScanParams);
2782 return VOS_STATUS_E_NOMEM;
2783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2784 /* Copy init Scan params to WDI structure */
2785 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2786 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2787 /* Store Init Req pointer, as this will be used for response */
2788 /* store Params pass it to WDI */
2789 pWdaParams->pWdaContext = pWDA;
2790 pWdaParams->wdaMsgParam = endScanParams;
2791 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2792 /* call DAL API to pass init scan request to DAL */
2793 status = WDI_EndScanReq(wdiEndScanParams,
2794 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2795 if(IS_WDI_STATUS_FAILURE(status))
2796 {
2797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2798 "Failure in End Scan WDI API, free all the memory "
2799 "It should be due to previous abort scan." );
2800 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2801 vos_mem_free(pWdaParams) ;
2802 endScanParams->status = eSIR_FAILURE ;
2803 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2804 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2805 return CONVERT_WDI2VOS_STATUS(status) ;
2806}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2807/*
2808 * FUNCTION: WDA_FinishScanReqCallback
2809 * Trigger Finish SCAN callback
2810 */
2811void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2812{
2813 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2814 tWDA_CbContext *pWDA;
2815 tFinishScanParams *finishScanParam;
2816 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2818 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2819 if(NULL == pWdaParams)
2820 {
2821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2822 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2823 VOS_ASSERT(0) ;
2824 return ;
2825 }
2826
2827 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2828 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2829 if(NULL == finishScanParam)
2830 {
2831 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2832 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2833 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2834 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2835 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2836 return ;
2837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2838 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2839 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2840 /*
2841 * Now Resume TX, if we reached here means, TX is already suspended, we
2842 * have to resume it unconditionaly
2843 */
2844 status = WDA_ResumeDataTx(pWDA) ;
2845
2846 if(VOS_STATUS_SUCCESS != status)
2847 {
2848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2849 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2850 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2851 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2852 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2853 return ;
2854}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2855/*
2856 * FUNCTION: WDA_ProcessFinshScanReq
2857 * Trigger Finish SCAN in WDI
2858 */
2859VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2860 tFinishScanParams *finishScanParams)
2861{
2862 WDI_Status status = WDI_STATUS_SUCCESS;
2863 WDI_FinishScanReqParamsType *wdiFinishScanParams =
2864 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
2865 sizeof(WDI_FinishScanReqParamsType)) ;
2866 tWDA_ReqParams *pWdaParams ;
2867 tANI_U8 i = 0;
2868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2869 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2870 if(NULL == wdiFinishScanParams)
2871 {
2872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2873 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874 VOS_ASSERT(0);
2875 return VOS_STATUS_E_NOMEM;
2876 }
2877 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2878 if(NULL == pWdaParams)
2879 {
2880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2881 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2882 VOS_ASSERT(0);
2883 vos_mem_free(wdiFinishScanParams);
2884 return VOS_STATUS_E_NOMEM;
2885 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2886 /* Copy init Scan params to WDI structure */
2887 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
2888 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
2889 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2890 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
2891 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
2892 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
2893 finishScanParams->frameLength ;
2894 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
2895 finishScanParams->currentOperChannel ;
2896 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
2897 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
2898 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2899 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
2900 {
2901 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2902 finishScanParams->scanEntry.bssIdx[i] ;
2903 }
2904
2905
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2906 /* if Frame length, copy macMgmtHdr ro WDI structure */
2907 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
2908 {
2909 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
2910 &finishScanParams->macMgmtHdr,
2911 sizeof(WDI_MacMgmtHdr)) ;
2912 }
2913 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2914 /* Store Init Req pointer, as this will be used for response */
2915 /* store Params pass it to WDI */
2916 pWdaParams->pWdaContext = pWDA;
2917 pWdaParams->wdaMsgParam = finishScanParams;
2918 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2919 /* call DAL API to pass init scan request to DAL */
2920 status = WDI_FinishScanReq(wdiFinishScanParams,
2921 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2922
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2923
2924 /*
2925 * WDI API returns failure..
2926 */
2927 if(IS_WDI_STATUS_FAILURE( status))
2928 {
2929 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2930 "Failure in Finish Scan WDI API, free all the memory " );
2931 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2932 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2933 finishScanParams->status = eSIR_FAILURE ;
2934 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
2935 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2936 return CONVERT_WDI2VOS_STATUS(status) ;
2937}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2938/*---------------------------------------------------------------------
2939 * ASSOC API's
2940 *---------------------------------------------------------------------
2941 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2942/*
2943 * FUNCTION: WDA_JoinReqCallback
2944 * Trigger Init SCAN callback
2945 */
2946void WDA_JoinReqCallback(WDI_Status status, void* pUserData)
2947{
2948 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2949 tWDA_CbContext *pWDA;
2950 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2952 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 if(NULL == pWdaParams)
2954 {
2955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2956 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2957 VOS_ASSERT(0) ;
2958 return ;
2959 }
2960 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2961 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2962 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
2963 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2964 /* reset macBSSID */
2965 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2966 /* reset macSTASelf */
2967 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2968 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2969 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2970 return ;
2971}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972/*
2973 * FUNCTION: WDA_ProcessJoinReq
2974 * Trigger Join REQ in WDI
2975 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2976VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
2977 tSwitchChannelParams* joinReqParam)
2978{
2979 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2980 WDI_JoinReqParamsType *wdiJoinReqParam =
2981 (WDI_JoinReqParamsType *)vos_mem_malloc(
2982 sizeof(WDI_JoinReqParamsType)) ;
2983 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2985 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2986 if(NULL == wdiJoinReqParam)
2987 {
2988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2989 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2990 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]2991 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2992 return VOS_STATUS_E_NOMEM;
2993 }
2994 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2995 if(NULL == pWdaParams)
2996 {
2997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2998 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2999 VOS_ASSERT(0);
3000 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3001 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3002 return VOS_STATUS_E_NOMEM;
3003 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3004
3005 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3006 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3007 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3008 {
3009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3010 "%s: received join request when BSSID or self-STA is NULL "
3011 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3012 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3013 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3014 VOS_ASSERT(0);
3015 vos_mem_free(wdiJoinReqParam);
3016 vos_mem_free(pWdaParams);
3017 joinReqParam->status = eSIR_FAILURE ;
3018 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3019 return VOS_STATUS_E_INVAL;
3020 }
3021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3022 /* copy the BSSID for pWDA */
3023 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3024 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3025 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3026 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3027 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3028 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3029#ifdef WLAN_FEATURE_VOWIFI
3030 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3031 joinReqParam->maxTxPower ;
3032#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3033 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3034 joinReqParam->localPowerConstraint ;
3035#endif
3036 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3037 joinReqParam->secondaryChannelOffset ;
3038 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3039
3040 wdiJoinReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3041 /* Store Init Req pointer, as this will be used for response */
3042 /* store Params pass it to WDI */
3043 pWdaParams->pWdaContext = pWDA;
3044 pWdaParams->wdaMsgParam = joinReqParam;
3045 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3046 status = WDI_JoinReq(wdiJoinReqParam,
3047 (WDI_JoinRspCb )WDA_JoinReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3048 if(IS_WDI_STATUS_FAILURE(status))
3049 {
3050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3051 "Failure in Join WDI API, free all the memory " );
3052 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3053 vos_mem_free(pWdaParams) ;
3054 joinReqParam->status = eSIR_FAILURE ;
3055 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3056 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3057 return CONVERT_WDI2VOS_STATUS(status) ;
3058}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3059/*
3060 * FUNCTION: WDA_SwitchChannelReqCallback
3061 * send Switch channel RSP back to PE
3062 */
3063void WDA_SwitchChannelReqCallback(
3064 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3065{
3066 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3067 tWDA_CbContext *pWDA;
3068 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3070 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3071 if(NULL == pWdaParams)
3072 {
3073 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3074 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3075 VOS_ASSERT(0) ;
3076 return ;
3077 }
3078 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3079 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3080
3081#ifdef WLAN_FEATURE_VOWIFI
3082 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3083#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3084 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3085 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3086 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3087 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3088 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 return ;
3090}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3091/*
3092 * FUNCTION: WDA_ProcessChannelSwitchReq
3093 * Request to WDI to switch channel REQ params.
3094 */
3095VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3096 tSwitchChannelParams *pSwitchChanParams)
3097{
3098 WDI_Status status = WDI_STATUS_SUCCESS ;
3099 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3100 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3101 sizeof(WDI_SwitchChReqParamsType)) ;
3102 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3104 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3105 if(NULL == wdiSwitchChanParam)
3106 {
3107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3108 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3109 VOS_ASSERT(0);
3110 return VOS_STATUS_E_NOMEM;
3111 }
3112 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3113 if(NULL == pWdaParams)
3114 {
3115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3116 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3117 VOS_ASSERT(0);
3118 vos_mem_free(wdiSwitchChanParam);
3119 return VOS_STATUS_E_NOMEM;
3120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3121 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3122#ifndef WLAN_FEATURE_VOWIFI
3123 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3124 pSwitchChanParams->localPowerConstraint;
3125#endif
3126 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3127 pSwitchChanParams->secondaryChannelOffset;
3128 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3129 /* Store req pointer, as this will be used for response */
3130 /* store Params pass it to WDI */
3131 pWdaParams->pWdaContext = pWDA;
3132 pWdaParams->wdaMsgParam = pSwitchChanParams;
3133 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3134#ifdef WLAN_FEATURE_VOWIFI
3135 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3136 = pSwitchChanParams->maxTxPower;
3137 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3138 pSwitchChanParams ->selfStaMacAddr,
3139 sizeof(tSirMacAddr));
3140#endif
3141 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3142 pSwitchChanParams->bssId,
3143 sizeof(tSirMacAddr));
3144
3145 status = WDI_SwitchChReq(wdiSwitchChanParam,
3146 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3147 if(IS_WDI_STATUS_FAILURE(status))
3148 {
3149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3150 "Failure in process channel switch Req WDI API, free all the memory " );
3151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3152 vos_mem_free(pWdaParams) ;
3153 pSwitchChanParams->status = eSIR_FAILURE ;
3154 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3155 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3156 return CONVERT_WDI2VOS_STATUS(status) ;
3157}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3158
3159/*
3160 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3161 * send Switch channel RSP back to PE
3162 */
3163void WDA_SwitchChannelReqCallback_V1(
3164 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3165 void* pUserData)
3166{
3167 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3168 tWDA_CbContext *pWDA;
3169 tSwitchChannelParams *pSwitchChanParams;
3170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3171 "<------ %s " ,__func__);
3172
3173 if (NULL == pWdaParams)
3174 {
3175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3176 "%s: pWdaParams received NULL", __func__);
3177 VOS_ASSERT(0);
3178 return ;
3179 }
3180 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3181 pSwitchChanParams =
3182 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3183 pSwitchChanParams->channelSwitchSrc =
3184 wdiSwitchChanRsp->channelSwitchSrc;
3185#ifdef WLAN_FEATURE_VOWIFI
3186 pSwitchChanParams->txMgmtPower =
3187 wdiSwitchChanRsp->ucTxMgmtPower;
3188#endif
3189 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3190 vos_mem_free(pWdaParams);
3191 pSwitchChanParams->status =
3192 wdiSwitchChanRsp->wdiStatus ;
3193 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3194 (void *)pSwitchChanParams , 0);
3195 return;
3196}
3197
3198/*
3199 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3200 * Request to WDI to switch channel REQ params.
3201 */
3202VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3203 tSwitchChannelParams *pSwitchChanParams)
3204{
3205 WDI_Status status = WDI_STATUS_SUCCESS ;
3206 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3207 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3208 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3209 tWDA_ReqParams *pWdaParams ;
3210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3211 "------> %s " ,__func__);
3212 if (NULL == wdiSwitchChanParam)
3213 {
3214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3215 "%s: VOS MEM Alloc Failure", __func__);
3216 VOS_ASSERT(0);
3217 return VOS_STATUS_E_NOMEM;
3218 }
3219 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3220 if (NULL == pWdaParams)
3221 {
3222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3223 "%s: VOS MEM Alloc Failure", __func__);
3224 VOS_ASSERT(0);
3225 vos_mem_free(wdiSwitchChanParam);
3226 return VOS_STATUS_E_NOMEM;
3227 }
3228 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3229 pSwitchChanParams->channelSwitchSrc;
3230
3231 wdiSwitchChanParam->wdiChInfo.ucChannel =
3232 pSwitchChanParams->channelNumber;
3233#ifndef WLAN_FEATURE_VOWIFI
3234 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3235 pSwitchChanParams->localPowerConstraint;
3236#endif
3237 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3238 pSwitchChanParams->secondaryChannelOffset;
3239 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3240 /* Store req pointer, as this will be used for response */
3241 /* store Params pass it to WDI */
3242 pWdaParams->pWdaContext = pWDA;
3243 pWdaParams->wdaMsgParam = pSwitchChanParams;
3244 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3245#ifdef WLAN_FEATURE_VOWIFI
3246 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3247 pSwitchChanParams->maxTxPower;
3248 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3249 pSwitchChanParams ->selfStaMacAddr,
3250 sizeof(tSirMacAddr));
3251#endif
3252 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3253 pSwitchChanParams->bssId,
3254 sizeof(tSirMacAddr));
3255
3256 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3257 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3258 pWdaParams);
3259 if (IS_WDI_STATUS_FAILURE(status))
3260 {
3261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3262 "Failure in process channel switch Req WDI "
3263 "API, free all the memory " );
3264 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3265 vos_mem_free(pWdaParams) ;
3266 pSwitchChanParams->status = eSIR_FAILURE ;
3267 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3268 (void *)pSwitchChanParams, 0) ;
3269 }
3270 return CONVERT_WDI2VOS_STATUS(status) ;
3271}
3272
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3273/*
3274 * FUNCTION: WDA_ConfigBssReqCallback
3275 * config BSS Req Callback, called by WDI
3276 */
3277void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3278 ,void* pUserData)
3279{
3280 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3281 tWDA_CbContext *pWDA;
3282 tAddBssParams *configBssReqParam;
3283 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3285 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3286 if(NULL == pWdaParams)
3287 {
3288 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3289 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3290 VOS_ASSERT(0) ;
3291 return ;
3292 }
3293 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3294 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3295 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3296 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3297 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3298 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3299 {
3300 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3301 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3302 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3303 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3304 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3305
3306 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3307 {
3308 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3309 {
3310 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3311 staConfigBssParam->staType = STA_ENTRY_BSSID;
3312 }
3313 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3314 (staConfigBssParam->staType == STA_ENTRY_SELF))
3315 {
3316 /* This is the 1st add BSS Req for the BTAMP STA */
3317 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3318 staConfigBssParam->staType = STA_ENTRY_BSSID;
3319 }
3320 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3321 (staConfigBssParam->staType == STA_ENTRY_PEER))
3322 {
3323 /* This is the 2nd ADD BSS Request that is sent
3324 * on the BTAMP STA side. The Sta type is
3325 * set to STA_ENTRY_PEER here.*/
3326 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3327 }
3328 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3329 (staConfigBssParam->staType == STA_ENTRY_SELF))
3330 {
3331 /* statype is already set by PE.
3332 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3333 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3334 staConfigBssParam->staType = STA_ENTRY_BSSID;
3335 }
3336 else
3337 {
3338 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3339 staConfigBssParam->staType = STA_ENTRY_PEER;
3340 }
3341 }
3342 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3343 {
3344 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3345 staConfigBssParam->staType = STA_ENTRY_SELF;
3346 }
3347 else
3348 {
3349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3350 "Invalid operation mode specified");
3351 VOS_ASSERT(0);
3352 }
3353
3354 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3355 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3356 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3357 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3358 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3359 sizeof(tSirMacAddr));
3360 staConfigBssParam->txChannelWidthSet =
3361 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3362 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3363 staConfigBssParam->htCapable)
3364 {
3365 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3366 wdiConfigBssRsp->ucBSSIdx;
3367 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3368 WDA_VALID_STA_INDEX ;
3369 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3370 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3371 wdiConfigBssRsp->ucBSSIdx,
3372 wdiConfigBssRsp->ucSTAIdx))
3373 {
3374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3375 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3376 VOS_ASSERT(0) ;
3377 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3378 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3379 {
3380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3381 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3382 VOS_ASSERT(0) ;
3383 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3384#ifdef WLAN_FEATURE_VOWIFI
3385 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3386#endif
3387 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3389 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3390 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3391 return ;
3392}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3393/*
3394 * FUNCTION: WDA_UpdateEdcaParamsForAC
3395 * Update WDI EDCA params with PE edca params
3396 */
3397void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3398 WDI_EdcaParamRecord *wdiEdcaParam,
3399 tSirMacEdcaParamRecord *macEdcaParam)
3400{
3401 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3402 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3403 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3404 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3405 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3406 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3407}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3408/*
3409 * FUNCTION: WDA_ProcessConfigBssReq
3410 * Configure BSS before starting Assoc with AP
3411 */
3412VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3413 tAddBssParams* configBssReqParam)
3414{
3415 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3416 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3417 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3419 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3420 if (NULL == configBssReqParam)
3421 {
3422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3423 "%s: configBssReqParam is NULL", __func__);
3424 return VOS_STATUS_E_INVAL;
3425 }
3426
3427 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3428 sizeof(WDI_ConfigBSSReqParamsType)) ;
3429
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3430 if(NULL == wdiConfigBssReqParam)
3431 {
3432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3433 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3434 VOS_ASSERT(0);
3435 return VOS_STATUS_E_NOMEM;
3436 }
3437 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3438 if(NULL == pWdaParams)
3439 {
3440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3441 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3442 VOS_ASSERT(0);
3443 vos_mem_free(wdiConfigBssReqParam);
3444 return VOS_STATUS_E_NOMEM;
3445 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3447 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3448 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3449 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3450 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3451 /* Store Init Req pointer, as this will be used for response */
3452 /* store Params pass it to WDI */
3453 pWdaParams->pWdaContext = pWDA;
3454 pWdaParams->wdaMsgParam = configBssReqParam;
3455 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3456 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3457 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3458 if(IS_WDI_STATUS_FAILURE(status))
3459 {
3460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3461 "Failure in Config BSS WDI API, free all the memory " );
3462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3463 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3464 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3465 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3466 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3467 return CONVERT_WDI2VOS_STATUS(status) ;
3468}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3469#ifdef ENABLE_HAL_COMBINED_MESSAGES
3470/*
3471 * FUNCTION: WDA_PostAssocReqCallback
3472 * Post ASSOC req callback, send RSP back to PE
3473 */
3474void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3475 void* pUserData)
3476{
3477 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3478 tPostAssocParams *postAssocReqParam =
3479 (tPostAssocParams *)pWDA->wdaMsgParam ;
3480 /*STA context within the BSS Params*/
3481 tAddStaParams *staPostAssocParam =
3482 &postAssocReqParam->addBssParams.staContext ;
3483 /*STA Params for self STA*/
3484 tAddStaParams *selfStaPostAssocParam =
3485 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3487 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3488 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3489 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3490 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3491 {
3492 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3493 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3494 sizeof(tSirMacAddr)) ;
3495 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3496 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3497 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3498 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3499 }
3500 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3501 pWDA->wdaWdiApiMsgParam = NULL;
3502 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3503 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3504 return ;
3505}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3506/*
3507 * FUNCTION: WDA_ProcessPostAssocReq
3508 * Trigger POST ASSOC processing in WDI
3509 */
3510VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3511 tPostAssocParams *postAssocReqParam)
3512{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3513 WDI_Status status = WDI_STATUS_SUCCESS ;
3514
3515 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3516 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3517 sizeof(WDI_PostAssocReqParamsType)) ;
3518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3519 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3520
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3521 if(NULL == wdiPostAssocReqParam)
3522 {
3523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3524 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3525 VOS_ASSERT(0);
3526 return VOS_STATUS_E_NOMEM;
3527 }
3528
3529 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3530 {
3531 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3532 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3533 VOS_ASSERT(0);
3534 return VOS_STATUS_E_FAILURE;
3535 }
3536
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3537 /* update BSS params into WDI structure */
3538 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3539 &postAssocReqParam->addBssParams) ;
3540 /* update STA params into WDI structure */
3541 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3542 &postAssocReqParam->addStaParams) ;
3543
3544 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3545 postAssocReqParam->addBssParams.highPerformance;
3546 WDA_UpdateEdcaParamsForAC(pWDA,
3547 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3548 &postAssocReqParam->addBssParams.acbe);
3549 WDA_UpdateEdcaParamsForAC(pWDA,
3550 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3551 &postAssocReqParam->addBssParams.acbk);
3552 WDA_UpdateEdcaParamsForAC(pWDA,
3553 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3554 &postAssocReqParam->addBssParams.acvi);
3555 WDA_UpdateEdcaParamsForAC(pWDA,
3556 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3557 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 /* Store Init Req pointer, as this will be used for response */
3559 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3560 /* store Params pass it to WDI */
3561 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3562 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3563 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3564 if(IS_WDI_STATUS_FAILURE(status))
3565 {
3566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3567 "Failure in Post Assoc WDI API, free all the memory " );
3568 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3569 pWDA->wdaWdiApiMsgParam = NULL;
3570 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3571 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3573 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3574 return CONVERT_WDI2VOS_STATUS(status) ;
3575}
3576#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3577/*
3578 * FUNCTION: WDA_AddStaReqCallback
3579 * ADD STA req callback, send RSP back to PE
3580 */
3581void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3582 void* pUserData)
3583{
3584 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3585 tWDA_CbContext *pWDA;
3586 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3588 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3589 if(NULL == pWdaParams)
3590 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,"%s: pWdaParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3592 VOS_ASSERT(0) ;
3593 return ;
3594 }
3595 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3596 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3597 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3598 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3599 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3600 {
3601 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3602 /*TODO: UMAC structure doesn't have these fields*/
3603 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3604 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3605 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3606 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3607 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3608 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3609#ifdef FEATURE_WLAN_TDLS
3610 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3611 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3612#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3613 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3614#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3615 {
3616 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3617 wdiConfigStaRsp->ucBssIdx;
3618 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3619 WDA_VALID_STA_INDEX ;
3620 }
3621 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3622 {
3623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3624 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3625 VOS_ASSERT(0) ;
3626 return ;
3627 }
3628 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3629 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3630 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3631 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3632 return ;
3633}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3634/*
3635 * FUNCTION: WDA_ConfigStaReq
3636 * Trigger Config STA processing in WDI
3637 */
3638VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3639 tAddStaParams *addStaReqParam)
3640{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3641 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3642 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3643 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3644 sizeof(WDI_ConfigSTAReqParamsType)) ;
3645 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3647 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3648 if(NULL == wdiConfigStaReqParam)
3649 {
3650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3651 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3652 VOS_ASSERT(0);
3653 return VOS_STATUS_E_NOMEM;
3654 }
3655 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3656 if(NULL == pWdaParams)
3657 {
3658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3659 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3660 VOS_ASSERT(0);
3661 vos_mem_free(wdiConfigStaReqParam);
3662 return VOS_STATUS_E_NOMEM;
3663 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3664 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3665 /* update STA params into WDI structure */
3666 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3667 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3668 /* Store Init Req pointer, as this will be used for response */
3669 /* store Params pass it to WDI */
3670 pWdaParams->pWdaContext = pWDA;
3671 pWdaParams->wdaMsgParam = addStaReqParam;
3672 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3673 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3674 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3675 if(IS_WDI_STATUS_FAILURE(status))
3676 {
3677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3678 "Failure in Config STA WDI API, free all the memory " );
3679 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3680 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3681 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3682 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3683 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3684 return CONVERT_WDI2VOS_STATUS(status) ;
3685}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3686/*
3687 * FUNCTION: WDA_DelBSSReqCallback
3688 * Dens DEL BSS RSP back to PE
3689 */
3690void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3691 void* pUserData)
3692{
3693 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3694 tWDA_CbContext *pWDA;
3695 tDeleteBssParams *delBssReqParam;
3696 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3698 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3699 if(NULL == pWdaParams)
3700 {
3701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3702 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3703 VOS_ASSERT(0) ;
3704 return ;
3705 }
3706 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3707 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3708 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3709 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3710 {
3711 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3712 sizeof(tSirMacAddr)) ;
3713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3714 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3715 {
3716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3717 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3718 VOS_ASSERT(0) ;
3719 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3720 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3721 {
3722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3723 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3724 VOS_ASSERT(0) ;
3725 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3726 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3727 {
3728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3729 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3730 VOS_ASSERT(0) ;
3731 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3732
3733 WLANTL_StartForwarding(staIdx,0,0);
3734
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3735 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3736 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3737 /* reset the the system role*/
3738 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3739
3740 /* Reset the BA related information */
3741 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3742 {
3743 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3744 {
3745 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3746 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
3747 /* Reset framesTxed counters here */
3748 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3749 {
3750 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3751 }
3752 }
3753 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3754 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3755 return ;
3756}
3757
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3758/*
3759 * FUNCTION: WDA_ProcessDelBssReq
3760 * Init DEL BSS req with WDI
3761 */
3762VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3763 tDeleteBssParams *delBssParam)
3764{
3765 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3766 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3767 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3768 sizeof(WDI_DelBSSReqParamsType)) ;
3769 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3771 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3772 if(NULL == wdiDelBssReqParam)
3773 {
3774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3775 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3776 VOS_ASSERT(0);
3777 return VOS_STATUS_E_NOMEM;
3778 }
3779 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3780 if(NULL == pWdaParams)
3781 {
3782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3783 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3784 VOS_ASSERT(0);
3785 vos_mem_free(wdiDelBssReqParam);
3786 return VOS_STATUS_E_NOMEM;
3787 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3788 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3789 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3790
3791 /* Store Init Req pointer, as this will be used for response */
3792 /* store Params pass it to WDI */
3793 pWdaParams->pWdaContext = pWDA;
3794 pWdaParams->wdaMsgParam = delBssParam;
3795 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3796 status = WDI_DelBSSReq(wdiDelBssReqParam,
3797 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3798 if(IS_WDI_STATUS_FAILURE(status))
3799 {
3800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3801 "Failure in Del BSS WDI API, free all the memory " );
3802 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3803 vos_mem_free(pWdaParams) ;
3804 delBssParam->status = eSIR_FAILURE ;
3805 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3806 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3807 return CONVERT_WDI2VOS_STATUS(status) ;
3808}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3809/*
3810 * FUNCTION: WDA_DelSTAReqCallback
3811 * Dens DEL STA RSP back to PE
3812 */
3813void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3814 void* pUserData)
3815{
3816 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3817 tWDA_CbContext *pWDA;
3818 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3820 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3821 if(NULL == pWdaParams)
3822 {
3823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3824 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3825 VOS_ASSERT(0) ;
3826 return ;
3827 }
3828 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3829 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3830 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3831 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
3832 {
3833 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
3834 {
3835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3836 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3837 VOS_ASSERT(0) ;
3838 }
3839 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3840 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3841 }
3842 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3843 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3844 /*Reset the BA information corresponding to this STAIdx */
3845 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
3846 WDA_INVALID_STA_INDEX;
3847 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
3848
3849 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3850 return ;
3851}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3852/*
3853 * FUNCTION: WDA_ProcessDelStaReq
3854 * Init DEL STA req with WDI
3855 */
3856VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
3857 tDeleteStaParams *delStaParam)
3858{
3859 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3860 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
3861 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
3862 sizeof(WDI_DelSTAReqParamsType)) ;
3863 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3865 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3866 if(NULL == wdiDelStaReqParam)
3867 {
3868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3869 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3870 VOS_ASSERT(0);
3871 return VOS_STATUS_E_NOMEM;
3872 }
3873 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3874 if(NULL == pWdaParams)
3875 {
3876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3877 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3878 VOS_ASSERT(0);
3879 vos_mem_free(wdiDelStaReqParam);
3880 return VOS_STATUS_E_NOMEM;
3881 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3882 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
3883 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3884 /* Store Init Req pointer, as this will be used for response */
3885 /* store Params pass it to WDI */
3886 pWdaParams->pWdaContext = pWDA;
3887 pWdaParams->wdaMsgParam = delStaParam;
3888 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3889 status = WDI_DelSTAReq(wdiDelStaReqParam,
3890 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3891 if(IS_WDI_STATUS_FAILURE(status))
3892 {
3893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3894 "Failure in Del STA WDI API, free all the memory status = %d",
3895 status );
3896 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3897 vos_mem_free(pWdaParams) ;
3898 delStaParam->status = eSIR_FAILURE ;
3899 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
3900 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3901 return CONVERT_WDI2VOS_STATUS(status) ;
3902}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3903void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
3904{
3905 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3906 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3907 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3909 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3910 if(NULL == pWdaParams)
3911 {
3912 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3913 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3914 VOS_ASSERT(0) ;
3915 return ;
3916 }
3917 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3918 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3919 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3920 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3921 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
3922 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
3923 pwdiAddSTASelfRsp->macSelfSta,
3924 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3925 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
3926 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
3927 if (pAddStaSelfRsp->status == eSIR_FAILURE)
3928 {
3929 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
3930 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
3931 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3932 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3933 return ;
3934}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3935
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3936/*
3937 * FUNCTION: WDA_ProcessAddStaSelfReq
3938 *
3939 */
3940VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
3941{
3942 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3943 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3944 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
3945 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
3946 sizeof(WDI_AddSTASelfReqParamsType)) ;
3947 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3949 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3950 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3951 if( NULL == wdiAddStaSelfReq )
3952 {
3953 VOS_ASSERT( 0 );
3954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3955 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3956 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
3957 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3958 return( VOS_STATUS_E_NOMEM );
3959 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3961 if( NULL == pWdaParams )
3962 {
3963 VOS_ASSERT( 0 );
3964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3965 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3966 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
3967 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3968 vos_mem_free(wdiAddStaSelfReq) ;
3969 return( VOS_STATUS_E_NOMEM );
3970 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3971 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3972 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]3973 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3974 /* Store Init Req pointer, as this will be used for response */
3975 /* store Params pass it to WDI */
3976 pWdaParams->pWdaContext = pWDA;
3977 pWdaParams->wdaMsgParam = pAddStaSelfReq;
3978 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3979 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3980
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3981 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3982 {
3983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3984 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3985 wstatus );
3986 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3987 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3988 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3989 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
3990 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3991 pAddStaSelfReq->status = eSIR_FAILURE ;
3992 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
3993 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3994 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3995}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3996/*
3997 * FUNCTION: WDA_DelSTASelfRespCallback
3998 *
3999 */
4000void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4001 wdiDelStaSelfRspParams , void* pUserData)
4002{
4003 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4004 tWDA_CbContext *pWDA;
4005 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4007 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4008 if (NULL == pWdaParams)
4009 {
4010 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4011 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4012 VOS_ASSERT(0);
4013 return;
4014 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4015 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4016 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4017 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4018 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4019
4020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4021 vos_mem_free(pWdaParams) ;
4022
4023 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4024 return ;
4025}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4026/*
4027 * FUNCTION: WDA_DelSTASelfReqCallback
4028 *
4029 */
4030void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4031 void* pUserData)
4032{
4033 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4034 tWDA_CbContext *pWDA;
4035 tDelStaSelfParams *delStaSelfParams;
4036
4037 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4038 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4039 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4040
4041 if (NULL == pWdaParams)
4042 {
4043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4044 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4045 VOS_ASSERT(0);
4046 return;
4047 }
4048
4049 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4050 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4051
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4052 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4053
4054 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4055 {
4056 VOS_ASSERT(0);
4057 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4058 vos_mem_free(pWdaParams) ;
4059 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4060 }
4061
4062 return ;
4063}
4064
4065/*
4066 * FUNCTION: WDA_DelSTASelfReq
4067 * Trigger Config STA processing in WDI
4068 */
4069VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4070 tDelStaSelfParams* pDelStaSelfReqParam)
4071{
4072 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4073 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4074 tWDA_ReqParams *pWdaParams = NULL;
4075 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4076 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4077 sizeof(WDI_DelSTASelfReqParamsType)) ;
4078
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4080 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4081 if( NULL == wdiDelStaSelfReq )
4082 {
4083 VOS_ASSERT( 0 );
4084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4085 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4086 return( VOS_STATUS_E_NOMEM );
4087 }
4088
4089 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4090 if( NULL == pWdaParams )
4091 {
4092 VOS_ASSERT( 0 );
4093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4094 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4095 vos_mem_free(wdiDelStaSelfReq) ;
4096 return( VOS_STATUS_E_NOMEM );
4097 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4098 pWdaParams->pWdaContext = pWDA;
4099 /* Store param pointer as passed in by caller */
4100 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4101 /* store Params pass it to WDI */
4102 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4103 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4104 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4105
4106 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4107 wdiDelStaSelfReq->pUserData = pWdaParams;
4108
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4109 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4110 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4111
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4112 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4113 {
4114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4115 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4116 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4117 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4118 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4119 vos_mem_free(pWdaParams) ;
4120 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4121 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4122 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4123 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4124}
4125
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4126/*
4127 * FUNCTION: WDA_SendMsg
4128 * Send Message back to PE
4129 */
4130void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4131 void *pBodyptr, tANI_U32 bodyVal)
4132{
4133 tSirMsgQ msg = {0} ;
4134 tANI_U32 status = VOS_STATUS_SUCCESS ;
4135 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4136 msg.type = msgType;
4137 msg.bodyval = bodyVal;
4138 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4139 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4140 if (VOS_STATUS_SUCCESS != status)
4141 {
4142 if(NULL != pBodyptr)
4143 {
4144 vos_mem_free(pBodyptr);
4145 }
4146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4147 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4148 VOS_ASSERT(0) ;
4149 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4150 return ;
4151}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4152/*
4153 * FUNCTION: WDA_UpdateBSSParams
4154 * Translated WDA/PE BSS info into WDI BSS info..
4155 */
4156void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4157 WDI_ConfigBSSReqInfoType *wdiBssParams,
4158 tAddBssParams *wdaBssParams)
4159{
4160 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4161 /* copy bssReq Params to WDI structure */
4162 vos_mem_copy(wdiBssParams->macBSSID,
4163 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4164 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4165 sizeof(tSirMacAddr)) ;
4166 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4167 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4168 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4169 wdiBssParams->ucShortSlotTimeSupported =
4170 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4171 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4172 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4173 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4174 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4175 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4176
4177 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4178 wdiBssParams->ucTXOPProtectionFullSupport =
4179 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4180 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4181 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4182 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4184 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4185 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4186 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4187
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4188 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4189
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4190 /* copy SSID into WDI structure */
4191 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4192 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4193 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4194 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4195 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4196 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4197#ifdef WLAN_FEATURE_VOWIFI
4198 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4199#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4200 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4201 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4202#ifdef WLAN_FEATURE_VOWIFI_11R
4203 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4204 if(wdiBssParams->bExtSetStaKeyParamValid)
4205 {
4206 /* copy set STA key params to WDI structure */
4207 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4208 wdaBssParams->extSetStaKeyParam.staIdx;
4209 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4210 wdaBssParams->extSetStaKeyParam.encType;
4211 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4212 wdaBssParams->extSetStaKeyParam.wepType;
4213 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4214 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4215 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4216 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4217 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4218 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4219 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4220 {
4221 WDA_GetWepKeysFromCfg( pWDA,
4222 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4223 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4224 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4225 }
4226 else
4227 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4228 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4229 keyIndex++)
4230 {
4231 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4232 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4233 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4234 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4235 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4236 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4237 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4238 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4239 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4240 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4241 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4242 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4243 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4244 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4245 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4246 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4247 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4248 }
4249 }
4250 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4251 }
4252 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4253 {
4254 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4255 sizeof(wdaBssParams->extSetStaKeyParam) );
4256 }
4257#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4258#ifdef WLAN_FEATURE_11AC
4259 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4260 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4261#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4262
4263 return ;
4264}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4265/*
4266 * FUNCTION: WDA_UpdateSTAParams
4267 * Translated WDA/PE BSS info into WDI BSS info..
4268 */
4269void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4270 WDI_ConfigStaReqInfoType *wdiStaParams,
4271 tAddStaParams *wdaStaParams)
4272{
4273 tANI_U8 i = 0;
4274 /* Update STA params */
4275 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4276 sizeof(tSirMacAddr)) ;
4277 wdiStaParams->usAssocId = wdaStaParams->assocId;
4278 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4279 wdiStaParams->staIdx = wdaStaParams->staIdx;
4280
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4281 wdiStaParams->ucShortPreambleSupported =
4282 wdaStaParams->shortPreambleSupported;
4283 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4284 sizeof(tSirMacAddr)) ;
4285 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4286
4287 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4288
4289 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4290 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4291 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4292 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4293 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4294 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4295 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4296
4297 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4298 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4299 wdiStaParams->wdiSupportedRates.opRateMode =
4300 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4301 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4302 {
4303 wdiStaParams->wdiSupportedRates.llbRates[i] =
4304 wdaStaParams->supportedRates.llbRates[i];
4305 }
4306 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4307 {
4308 wdiStaParams->wdiSupportedRates.llaRates[i] =
4309 wdaStaParams->supportedRates.llaRates[i];
4310 }
4311 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4312 {
4313 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4314 wdaStaParams->supportedRates.aniLegacyRates[i];
4315 }
4316 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4317 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4318#ifdef WLAN_FEATURE_11AC
4319 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4320 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4321 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4322 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4323#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4324 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4325 {
4326 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4327 wdaStaParams->supportedRates.supportedMCSSet[i];
4328 }
4329 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4330 wdaStaParams->supportedRates.rxHighestDataRate;
4331
4332 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4333
4334 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4335
4336 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4337 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4338 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4339
4340 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4341 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4342 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4343 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4344 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4345#ifdef WLAN_FEATURE_11AC
4346 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4347 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4348 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4349#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4350 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4351 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4352 return ;
4353}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4354/*
4355 * -------------------------------------------------------------------------
4356 * CFG update to WDI
4357 * -------------------------------------------------------------------------
4358 */
4359
4360 /*
4361 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4362 * Convert the WNI CFG ID to HAL CFG ID
4363 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4364static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4365{
4366 switch(wniCfgId)
4367 {
4368 case WNI_CFG_STA_ID:
4369 return QWLAN_HAL_CFG_STA_ID;
4370 case WNI_CFG_CURRENT_TX_ANTENNA:
4371 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4372 case WNI_CFG_CURRENT_RX_ANTENNA:
4373 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4374 case WNI_CFG_LOW_GAIN_OVERRIDE:
4375 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4376 case WNI_CFG_POWER_STATE_PER_CHAIN:
4377 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4378 case WNI_CFG_CAL_PERIOD:
4379 return QWLAN_HAL_CFG_CAL_PERIOD;
4380 case WNI_CFG_CAL_CONTROL:
4381 return QWLAN_HAL_CFG_CAL_CONTROL;
4382 case WNI_CFG_PROXIMITY:
4383 return QWLAN_HAL_CFG_PROXIMITY;
4384 case WNI_CFG_NETWORK_DENSITY:
4385 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4386 case WNI_CFG_MAX_MEDIUM_TIME:
4387 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4388 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4389 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4390 case WNI_CFG_RTS_THRESHOLD:
4391 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4392 case WNI_CFG_SHORT_RETRY_LIMIT:
4393 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4394 case WNI_CFG_LONG_RETRY_LIMIT:
4395 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4396 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4397 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4398 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4399 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4400 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4401 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4402 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4403 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4404 case WNI_CFG_FIXED_RATE:
4405 return QWLAN_HAL_CFG_FIXED_RATE;
4406 case WNI_CFG_RETRYRATE_POLICY:
4407 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4408 case WNI_CFG_RETRYRATE_SECONDARY:
4409 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4410 case WNI_CFG_RETRYRATE_TERTIARY:
4411 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4412 case WNI_CFG_FORCE_POLICY_PROTECTION:
4413 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4414 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4415 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4416 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4417 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4418 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4419 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4420 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4421 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4422 case WNI_CFG_MAX_BA_SESSIONS:
4423 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4424 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4425 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4426 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4427 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4428 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4429 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4430 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4431 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4432 case WNI_CFG_STATS_PERIOD:
4433 return QWLAN_HAL_CFG_STATS_PERIOD;
4434 case WNI_CFG_CFP_MAX_DURATION:
4435 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4436#if 0 /*This is not part of CFG*/
4437 case WNI_CFG_FRAME_TRANS_ENABLED:
4438 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4439#endif
4440 case WNI_CFG_DTIM_PERIOD:
4441 return QWLAN_HAL_CFG_DTIM_PERIOD;
4442 case WNI_CFG_EDCA_WME_ACBK:
4443 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4444 case WNI_CFG_EDCA_WME_ACBE:
4445 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4446 case WNI_CFG_EDCA_WME_ACVI:
4447 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4448 case WNI_CFG_EDCA_WME_ACVO:
4449 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4450#if 0
4451 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4452 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4453 case WNI_CFG_TELE_BCN_TRANS_LI:
4454 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4455 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4456 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4457 case WNI_CFG_TELE_BCN_MAX_LI:
4458 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4459 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4460 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4461#endif
4462 case WNI_CFG_ENABLE_CLOSE_LOOP:
4463 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4464 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4465 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4466 default:
4467 {
4468 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4469 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4470 wniCfgId);
4471 return VOS_STATUS_E_INVAL;
4472 }
4473 }
4474}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4475/*
4476 * FUNCTION: WDA_UpdateCfgCallback
4477 *
4478 */
4479void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4480{
4481 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4482 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4483 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4485 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4486 /*
4487 * currently there is no response message is expected between PE and
4488 * WDA, Failure return from WDI is a ASSERT condition
4489 */
4490 if(WDI_STATUS_SUCCESS != wdiStatus)
4491 {
4492 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4493 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4494 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4495 }
4496
4497 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4498 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4499 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4500 return ;
4501}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4502/*
4503 * FUNCTION: WDA_UpdateCfg
4504 *
4505 */
4506VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4507{
4508
4509 WDI_Status status = WDI_STATUS_SUCCESS ;
4510 tANI_U32 val =0;
4511 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4512 tHalCfg *configData;
4513 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4514 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4516 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4517 if (NULL == pMac )
4518 {
4519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4520 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4521 return VOS_STATUS_E_FAILURE;
4522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4523 if(WDA_START_STATE != pWDA->wdaState)
4524 {
4525 return VOS_STATUS_E_FAILURE;
4526 }
4527
4528 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4529 {
4530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4531 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4532 VOS_ASSERT(0);
4533 return VOS_STATUS_E_FAILURE;
4534 }
4535
4536 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4537 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4538 if(NULL == wdiCfgReqParam)
4539 {
4540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4541 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4542 VOS_ASSERT(0);
4543 return VOS_STATUS_E_NOMEM;
4544 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4545 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4546 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4547 if(NULL == wdiCfgReqParam->pConfigBuffer)
4548 {
4549 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4550 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4551 vos_mem_free(wdiCfgReqParam);
4552 VOS_ASSERT(0);
4553 return VOS_STATUS_E_NOMEM;
4554 }
4555
4556 /*convert the WNI CFG Id to HAL CFG Id*/
4557 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4558 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4559
4560 /*TODO: revisit this for handling string parameters */
4561 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4562 &val) != eSIR_SUCCESS)
4563 {
4564 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4565 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4566 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4567 vos_mem_free(wdiCfgReqParam);
4568 return eSIR_FAILURE;
4569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4570 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4571 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4572 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4573 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4574 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4575
4576 /* store Params pass it to WDI */
4577 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4578#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4579 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4580 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4581 if(IS_WDI_STATUS_FAILURE(status))
4582 {
4583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4584 "Failure in Update CFG WDI API, free all the memory " );
4585 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4586 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4587 pWDA->wdaWdiCfgApiMsgParam = NULL;
4588 /* Failure is not expected */
4589 VOS_ASSERT(0) ;
4590 }
4591#else
4592 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4593 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4594 pWDA->wdaWdiCfgApiMsgParam = NULL;
4595#endif
4596 return CONVERT_WDI2VOS_STATUS(status) ;
4597}
4598
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4599VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4600 v_U8_t *pDefaultKeyId,
4601 v_U8_t *pNumKeys,
4602 WDI_KeysType *pWdiKeys )
4603{
4604 v_U32_t i, j, defKeyId = 0;
4605 v_U32_t val = SIR_MAC_KEY_LENGTH;
4606 VOS_STATUS status = WDI_STATUS_SUCCESS;
4607 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4608 if (NULL == pMac )
4609 {
4610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4611 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4612 return VOS_STATUS_E_FAILURE;
4613 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4614 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4615 &defKeyId ))
4616 {
4617 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4618 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4619 }
4620
4621 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4622 /* Need to extract ALL of the configured WEP Keys */
4623 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4624 {
4625 val = SIR_MAC_KEY_LENGTH;
4626 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4627 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4628 pWdiKeys[j].key,
4629 &val ))
4630 {
4631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4632 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4633 }
4634 else
4635 {
4636 pWdiKeys[j].keyId = (tANI_U8) i;
4637 /*
4638 * Actually, a DC (Don't Care) because
4639 * this is determined (and set) by PE/MLME
4640 */
4641 pWdiKeys[j].unicast = 0;
4642 /*
4643 * Another DC (Don't Care)
4644 */
4645 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4646 /* Another DC (Don't Care). Unused for WEP */
4647 pWdiKeys[j].paeRole = 0;
4648 /* Determined from wlan_cfgGetStr() above.*/
4649 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4650 j++;
4651 *pNumKeys = (tANI_U8) j;
4652 }
4653 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4654 return status;
4655}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4656/*
4657 * FUNCTION: WDA_SetBssKeyReqCallback
4658 * send SET BSS key RSP back to PE
4659 */
4660void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4661{
4662 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4663 tWDA_CbContext *pWDA;
4664 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4666 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4667 if(NULL == pWdaParams)
4668 {
4669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4670 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4671 VOS_ASSERT(0) ;
4672 return ;
4673 }
4674 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4675 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4676 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4677 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4678 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4679 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4680 return ;
4681}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4682/*
4683 * FUNCTION: WDA_ProcessSetBssKeyReq
4684 * Request to WDI for programming the BSS key( key for
4685 * broadcast/multicast frames Encryption)
4686 */
4687VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4688 tSetBssKeyParams *setBssKeyParams )
4689{
4690 WDI_Status status = WDI_STATUS_SUCCESS ;
4691 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4692 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4693 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4694 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4695 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4697 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4698 if(NULL == wdiSetBssKeyParam)
4699 {
4700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4701 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4702 VOS_ASSERT(0);
4703 return VOS_STATUS_E_NOMEM;
4704 }
4705 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4706 if(NULL == pWdaParams)
4707 {
4708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4709 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4710 VOS_ASSERT(0);
4711 vos_mem_free(wdiSetBssKeyParam);
4712 return VOS_STATUS_E_NOMEM;
4713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4715 /* copy set BSS params to WDI structure */
4716 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4717 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4718 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4719 if(setBssKeyParams->encType != eSIR_ED_NONE)
4720 {
4721 if( setBssKeyParams->numKeys == 0 &&
4722 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4723 setBssKeyParams->encType == eSIR_ED_WEP104))
4724 {
4725 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4726 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4727 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4728 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4729 }
4730 else
4731 {
4732 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4733 {
4734 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4735 setBssKeyParams->key[keyIndex].keyId;
4736 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4737 setBssKeyParams->key[keyIndex].unicast;
4738 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4739 setBssKeyParams->key[keyIndex].keyDirection;
4740 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4741 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4742 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4743 setBssKeyParams->key[keyIndex].paeRole;
4744 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4745 setBssKeyParams->key[keyIndex].keyLength;
4746 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4747 setBssKeyParams->key[keyIndex].key,
4748 SIR_MAC_MAX_KEY_LENGTH);
4749 }
4750 }
4751 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4752 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4753 setBssKeyParams->singleTidRc;
4754 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4755 /* Store set key pointer, as this will be used for response */
4756 /* store Params pass it to WDI */
4757 pWdaParams->pWdaContext = pWDA;
4758 pWdaParams->wdaMsgParam = setBssKeyParams;
4759 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4760 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4761 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4762
4763 if(IS_WDI_STATUS_FAILURE(status))
4764 {
4765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4766 "Failure in Set BSS Key Req WDI API, free all the memory " );
4767 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4768 vos_mem_free(pWdaParams) ;
4769 setBssKeyParams->status = eSIR_FAILURE ;
4770 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4771 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4772 return CONVERT_WDI2VOS_STATUS(status) ;
4773}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4774/*
4775 * FUNCTION: WDA_RemoveBssKeyReqCallback
4776 * send SET BSS key RSP back to PE
4777 */
4778void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4779{
4780 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4781 tWDA_CbContext *pWDA;
4782 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4784 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4785 if(NULL == pWdaParams)
4786 {
4787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4788 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4789 VOS_ASSERT(0) ;
4790 return ;
4791 }
4792 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4793 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4794 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4795 vos_mem_free(pWdaParams) ;
4796
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4797 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4798 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4799 return ;
4800}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4801/*
4802 * FUNCTION: WDA_ProcessRemoveBssKeyReq
4803 * Request to WDI to remove the BSS key( key for broadcast/multicast
4804 * frames Encryption)
4805 */
4806VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
4807 tRemoveBssKeyParams *removeBssKeyParams )
4808{
4809 WDI_Status status = WDI_STATUS_SUCCESS ;
4810 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
4811 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
4812 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
4813 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4815 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4816 if(NULL == wdiRemoveBssKeyParam)
4817 {
4818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4819 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4820 VOS_ASSERT(0);
4821 return VOS_STATUS_E_NOMEM;
4822 }
4823 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4824 if(NULL == pWdaParams)
4825 {
4826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4827 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4828 VOS_ASSERT(0);
4829 vos_mem_free(wdiRemoveBssKeyParam);
4830 return VOS_STATUS_E_NOMEM;
4831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4832 /* copy Remove BSS key params to WDI structure*/
4833 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
4834 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
4835 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
4836 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
4837 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4838 /* Store remove key pointer, as this will be used for response */
4839 /* store Params pass it to WDI */
4840 pWdaParams->pWdaContext = pWDA;
4841 pWdaParams->wdaMsgParam = removeBssKeyParams;
4842 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4843 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
4844 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4845 if(IS_WDI_STATUS_FAILURE(status))
4846 {
4847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4848 "Failure in Remove BSS Key Req WDI API, free all the memory " );
4849 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4850 vos_mem_free(pWdaParams) ;
4851 removeBssKeyParams->status = eSIR_FAILURE ;
4852 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
4853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4854 return CONVERT_WDI2VOS_STATUS(status) ;
4855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4856/*
4857 * FUNCTION: WDA_SetBssKeyReqCallback
4858 * send SET BSS key RSP back to PE
4859 */
4860void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
4861{
4862 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4863 tWDA_CbContext *pWDA;
4864 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4866 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4867 if(NULL == pWdaParams)
4868 {
4869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4870 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871 VOS_ASSERT(0) ;
4872 return ;
4873 }
4874 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4875 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4876 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4877 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4878 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4879 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4880 return ;
4881}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4882/*
4883 * FUNCTION: WDA_ProcessSetStaKeyReq
4884 * Request to WDI for programming the STA key( key for Unicast frames
4885 * Encryption)
4886 */
4887VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
4888 tSetStaKeyParams *setStaKeyParams )
4889{
4890 WDI_Status status = WDI_STATUS_SUCCESS ;
4891 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
4892 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
4893 sizeof(WDI_SetSTAKeyReqParamsType)) ;
4894 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4895 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4897 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4898 if(NULL == wdiSetStaKeyParam)
4899 {
4900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4901 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4902 VOS_ASSERT(0);
4903 return VOS_STATUS_E_NOMEM;
4904 }
4905 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4906 if(NULL == pWdaParams)
4907 {
4908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4909 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4910 VOS_ASSERT(0);
4911 vos_mem_free(wdiSetStaKeyParam);
4912 return VOS_STATUS_E_NOMEM;
4913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4914 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4915 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4916 /* copy set STA key params to WDI structure */
4917 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
4918 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
4919 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
4920 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 if(setStaKeyParams->encType != eSIR_ED_NONE)
4922 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4923 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4924 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
4925 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4926 {
4927 WDA_GetWepKeysFromCfg( pWDA,
4928 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
4929 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
4930 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
4931 }
4932 else
4933 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4934 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4935 keyIndex++)
4936 {
4937 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
4938 setStaKeyParams->key[keyIndex].keyId;
4939 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
4940 setStaKeyParams->key[keyIndex].unicast;
4941 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
4942 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4943 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
4944 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4945 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
4946 setStaKeyParams->key[keyIndex].paeRole;
4947 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
4948 setStaKeyParams->key[keyIndex].keyLength;
4949 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
4950 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4951 /* set default index to index which have key direction as WDI_TX_DEFAULT */
4952 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
4953 {
4954 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
4955 }
4956 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4957 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
4958 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4959 }
4960 }
4961 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
4962 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963 /* Store set key pointer, as this will be used for response */
4964 /* store Params pass it to WDI */
4965 pWdaParams->pWdaContext = pWDA;
4966 pWdaParams->wdaMsgParam = setStaKeyParams;
4967 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4968 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
4969 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4970 if(IS_WDI_STATUS_FAILURE(status))
4971 {
4972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4973 "Failure in set STA Key Req WDI API, free all the memory " );
4974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4975 vos_mem_free(pWdaParams) ;
4976 setStaKeyParams->status = eSIR_FAILURE ;
4977 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
4978 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4979 return CONVERT_WDI2VOS_STATUS(status) ;
4980}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4981/*
4982 * FUNCTION: WDA_SetBcastStaKeyReqCallback
4983 * send SET Bcast STA key RSP back to PE
4984 */
4985void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
4986{
4987 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4988 tWDA_CbContext *pWDA;
4989 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4991 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4992 if(NULL == pWdaParams)
4993 {
4994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4995 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4996 VOS_ASSERT(0) ;
4997 return ;
4998 }
4999 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5000 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5001 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5002 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5003 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5004 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5005 return ;
5006}
5007
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5008/*
5009 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5010 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5011 * Encryption)
5012 */
5013VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5014 tSetStaKeyParams *setStaKeyParams )
5015{
5016 WDI_Status status = WDI_STATUS_SUCCESS ;
5017 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5018 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5019 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5020 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5021 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5023 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5024 if(NULL == wdiSetStaKeyParam)
5025 {
5026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5027 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5028 VOS_ASSERT(0);
5029 return VOS_STATUS_E_NOMEM;
5030 }
5031 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5032 if(NULL == pWdaParams)
5033 {
5034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5035 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5036 VOS_ASSERT(0);
5037 vos_mem_free(wdiSetStaKeyParam);
5038 return VOS_STATUS_E_NOMEM;
5039 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5040 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5041 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5042 /* copy set STA key params to WDI structure */
5043 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5044 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5045 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5046 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5047 if(setStaKeyParams->encType != eSIR_ED_NONE)
5048 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5049 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5050 keyIndex++)
5051 {
5052 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5053 setStaKeyParams->key[keyIndex].keyId;
5054 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5055 setStaKeyParams->key[keyIndex].unicast;
5056 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5057 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5058 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5059 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5060 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5061 setStaKeyParams->key[keyIndex].paeRole;
5062 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5063 setStaKeyParams->key[keyIndex].keyLength;
5064 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5065 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5066 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5067 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5068 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5069 }
5070 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5071 /* Store set key pointer, as this will be used for response */
5072 /* store Params pass it to WDI */
5073 pWdaParams->pWdaContext = pWDA;
5074 pWdaParams->wdaMsgParam = setStaKeyParams;
5075 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5076 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5077 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5078 if(IS_WDI_STATUS_FAILURE(status))
5079 {
5080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5081 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5082 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5083 vos_mem_free(pWdaParams) ;
5084 setStaKeyParams->status = eSIR_FAILURE ;
5085 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5087 return CONVERT_WDI2VOS_STATUS(status) ;
5088}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5089/*
5090 * FUNCTION: WDA_RemoveStaKeyReqCallback
5091 * send SET BSS key RSP back to PE
5092 */
5093void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5094{
5095 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5096 tWDA_CbContext *pWDA;
5097 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5099 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5100 if(NULL == pWdaParams)
5101 {
5102 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5103 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5104 VOS_ASSERT(0) ;
5105 return ;
5106 }
5107 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5108 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5109 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5110 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5111 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5112 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5113 return ;
5114}
5115
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5116/*
5117 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5118 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5119 */
5120VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5121 tRemoveStaKeyParams *removeStaKeyParams )
5122{
5123 WDI_Status status = WDI_STATUS_SUCCESS ;
5124 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5125 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5126 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5127 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5129 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5130 if(NULL == wdiRemoveStaKeyParam)
5131 {
5132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5133 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5134 VOS_ASSERT(0);
5135 return VOS_STATUS_E_NOMEM;
5136 }
5137 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5138 if(NULL == pWdaParams)
5139 {
5140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5141 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5142 VOS_ASSERT(0);
5143 vos_mem_free(wdiRemoveStaKeyParam);
5144 return VOS_STATUS_E_NOMEM;
5145 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5146 /* copy remove STA key params to WDI structure*/
5147 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5148 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5149 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5150 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5151 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5152 /* Store remove key pointer, as this will be used for response */
5153 /* store Params pass it to WDI */
5154 pWdaParams->pWdaContext = pWDA;
5155 pWdaParams->wdaMsgParam = removeStaKeyParams;
5156 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5157 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5158 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5159 if(IS_WDI_STATUS_FAILURE(status))
5160 {
5161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5162 "Failure in remove STA Key Req WDI API, free all the memory " );
5163 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5164 vos_mem_free(pWdaParams) ;
5165 removeStaKeyParams->status = eSIR_FAILURE ;
5166 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5167 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5168 return CONVERT_WDI2VOS_STATUS(status) ;
5169}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5170/*
5171 * FUNCTION: WDA_IsHandleSetLinkStateReq
5172 * Update the WDA state and return the status to handle this message or not
5173 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5174WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5175 tWDA_CbContext *pWDA,
5176 tLinkStateParams *linkStateParams)
5177{
5178 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5179 switch(linkStateParams->state)
5180 {
5181 case eSIR_LINK_PREASSOC_STATE:
5182 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5183 /*
5184 * set the WDA state to PRE ASSOC
5185 * copy the BSSID into pWDA to use it in join request and return,
5186 * No need to handle these messages.
5187 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5188 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5189 {
5190 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5191 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5192 }
5193 else
5194 {
5195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5196 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5197 VOS_ASSERT(0);
5198 }
5199
5200 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5201 {
5202 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5203 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5204 }
5205 else
5206 {
5207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5208 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5209 VOS_ASSERT(0);
5210 }
5211
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5212 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5213 *channel and after ) so reset the WDA state to ready when the second
5214 * time UMAC issue the link state with PREASSOC
5215 */
5216 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5217 {
5218 /* RESET WDA state back to WDA_READY_STATE */
5219 pWDA->wdaState = WDA_READY_STATE;
5220 }
5221 else
5222 {
5223 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5224 }
5225 //populate linkState info in WDACbCtxt
5226 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5227 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5228 default:
5229 if(pWDA->wdaState != WDA_READY_STATE)
5230 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5231 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5232 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5233 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5234 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5235 *the ASSERT in WDA_Stop during module unload.*/
5236 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5237 {
5238 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5239 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5240 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5241 else
5242 {
5243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5244 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5245 status = WDA_IGNORE_SET_LINK_STATE;
5246 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5247 }
5248 break;
5249 }
5250
5251 return status;
5252}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5253/*
5254 * FUNCTION: WDA_SetLinkStateCallback
5255 * call back function for set link state from WDI
5256 */
5257void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5258{
5259 tWDA_CbContext *pWDA;
5260 tLinkStateParams *linkStateParams;
5261 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5263 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5264 if(NULL == pWdaParams)
5265 {
5266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5267 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5268 VOS_ASSERT(0) ;
5269 return ;
5270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5271 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5272 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 /*
5274 * In STA mode start the BA activity check timer after association
5275 * and in AP mode start BA activity check timer after BSS start */
5276 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5277 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5278 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5279 ((status == WDI_STATUS_SUCCESS) &&
5280 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5281 {
5282 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5284 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5285 /*
5286 * No respone required for WDA_SET_LINK_STATE so free the request
5287 * param here
5288 */
5289 if( pWdaParams != NULL )
5290 {
5291 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5292 {
5293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5294 }
5295 vos_mem_free(pWdaParams);
5296 }
5297 return ;
5298}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5299/*
5300 * FUNCTION: WDA_ProcessSetLinkState
5301 * Request to WDI to set the link status.
5302 */
5303VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5304 tLinkStateParams *linkStateParams)
5305{
5306 WDI_Status status = WDI_STATUS_SUCCESS ;
5307 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5308 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5309 sizeof(WDI_SetLinkReqParamsType)) ;
5310 tWDA_ReqParams *pWdaParams ;
5311 tpAniSirGlobal pMac;
5312 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5313
5314 if(NULL == pMac)
5315 {
5316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5317 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5318 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5319 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5320 return VOS_STATUS_E_FAILURE;
5321 }
5322
5323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5324 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5325 if(NULL == wdiSetLinkStateParam)
5326 {
5327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5328 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5329 VOS_ASSERT(0);
5330 return VOS_STATUS_E_NOMEM;
5331 }
5332 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5333 if(NULL == pWdaParams)
5334 {
5335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5336 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5337 VOS_ASSERT(0);
5338 vos_mem_free(wdiSetLinkStateParam);
5339 return VOS_STATUS_E_NOMEM;
5340 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5341 if(WDA_IGNORE_SET_LINK_STATE ==
5342 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5343 {
5344 status = WDI_STATUS_E_FAILURE;
5345 }
5346 else
5347 {
5348 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5349 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5350 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5351 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5352 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5353 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5354 pWdaParams->pWdaContext = pWDA;
5355 /* Store remove key pointer, as this will be used for response */
5356 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5357 /* store Params pass it to WDI */
5358 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5359 /* Stop Timer only other than GO role and concurrent session */
5360 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5361 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5362 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5363 {
5364 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5366 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5367 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5368 if(IS_WDI_STATUS_FAILURE(status))
5369 {
5370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5371 "Failure in set link state Req WDI API, free all the memory " );
5372 }
5373 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5374 if(IS_WDI_STATUS_FAILURE(status))
5375 {
5376 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5377 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5378 vos_mem_free(pWdaParams);
5379 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5380 return CONVERT_WDI2VOS_STATUS(status) ;
5381}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5382/*
5383 * FUNCTION: WDA_GetStatsReqParamsCallback
5384 * send the response to PE with Stats received from WDI
5385 */
5386void WDA_GetStatsReqParamsCallback(
5387 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5388 void* pUserData)
5389{
5390 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5391 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5392
5393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5394 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5395 pGetPEStatsRspParams =
5396 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5397 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5398
5399 if(NULL == pGetPEStatsRspParams)
5400 {
5401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5402 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5403 VOS_ASSERT(0);
5404 return;
5405 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5406 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5407 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5408 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5409 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5410
5411 //Fill the Session Id Properly in PE
5412 pGetPEStatsRspParams->sessionId = 0;
5413 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5414 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5415 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5416 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5417 vos_mem_copy( pGetPEStatsRspParams + 1,
5418 wdiGetStatsRsp + 1,
5419 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5420 /* send response to UMAC*/
5421 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5422
5423 return;
5424}
5425
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5426/*
5427 * FUNCTION: WDA_ProcessGetStatsReq
5428 * Request to WDI to get the statistics
5429 */
5430VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5431 tAniGetPEStatsReq *pGetStatsParams)
5432{
5433 WDI_Status status = WDI_STATUS_SUCCESS ;
5434 WDI_GetStatsReqParamsType wdiGetStatsParam;
5435 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5437 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5438 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5439 pGetStatsParams->staId;
5440 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5441 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5442 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5443 status = WDI_GetStatsReq(&wdiGetStatsParam,
5444 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5445 if(IS_WDI_STATUS_FAILURE(status))
5446 {
5447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5448 "Failure in Get Stats Req WDI API, free all the memory " );
5449 pGetPEStatsRspParams =
5450 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5451 if(NULL == pGetPEStatsRspParams)
5452 {
5453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5454 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5455 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5456 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5457 return VOS_STATUS_E_NOMEM;
5458 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5459 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5460 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5461 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5462 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5463 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5464 (void *)pGetPEStatsRspParams, 0) ;
5465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5466 /* Free the request message */
5467 vos_mem_free(pGetStatsParams);
5468 return CONVERT_WDI2VOS_STATUS(status);
5469}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5470
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5471#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5472/*
5473 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5474 * send the response to PE with roam Rssi received from WDI
5475 */
5476void WDA_GetRoamRssiReqParamsCallback(
5477 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5478 void* pUserData)
5479{
5480 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5481 tWDA_CbContext *pWDA = NULL;
5482 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5483 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5485 "<------ %s " ,__func__);
5486 if(NULL == pWdaParams)
5487 {
5488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5489 "%s: pWdaParams received NULL", __func__);
5490 VOS_ASSERT(0) ;
5491 return ;
5492 }
5493 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5494 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5495
5496 if(NULL == pGetRoamRssiReqParams)
5497 {
5498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5499 "%s: pGetRoamRssiReqParams received NULL", __func__);
5500 VOS_ASSERT(0);
5501 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5502 vos_mem_free(pWdaParams);
5503 return ;
5504 }
5505 pGetRoamRssiRspParams =
5506 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5507
5508 if(NULL == pGetRoamRssiRspParams)
5509 {
5510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5511 "%s: VOS MEM Alloc Failure", __func__);
5512 VOS_ASSERT(0);
5513 return;
5514 }
5515 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5516 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5517 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5518 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5519 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5520
5521 /* Assign get roam rssi req (backup) in to the response */
5522 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5523
5524 /* free WDI command buffer */
5525 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5526 vos_mem_free(pWdaParams) ;
5527
5528 /* send response to UMAC*/
5529 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5530
5531 return;
5532}
5533
5534
5535
5536/*
5537 * FUNCTION: WDA_ProcessGetRoamRssiReq
5538 * Request to WDI to get the statistics
5539 */
5540VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5541 tAniGetRssiReq *pGetRoamRssiParams)
5542{
5543 WDI_Status status = WDI_STATUS_SUCCESS ;
5544 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5545 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5546 tWDA_ReqParams *pWdaParams = NULL;
5547
5548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5549 "------> %s " ,__func__);
5550 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5551 pGetRoamRssiParams->staId;
5552 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5553
5554 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5555 if(NULL == pWdaParams)
5556 {
5557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5558 "%s: VOS MEM Alloc Failure", __func__);
5559 VOS_ASSERT(0);
5560 return VOS_STATUS_E_NOMEM;
5561 }
5562
5563 /* Store Init Req pointer, as this will be used for response */
5564 pWdaParams->pWdaContext = pWDA;
5565
5566 /* Take Get roam Rssi req backup as it stores the callback to be called after
5567 receiving the response */
5568 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5569 pWdaParams->wdaWdiApiMsgParam = NULL;
5570
5571 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5572 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5573 if(IS_WDI_STATUS_FAILURE(status))
5574 {
5575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5576 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5577 pGetRoamRssiRspParams =
5578 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5579 if(NULL == pGetRoamRssiRspParams)
5580 {
5581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5582 "%s: VOS MEM Alloc Failure", __func__);
5583 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5584 vos_mem_free(pGetRoamRssiParams);
5585 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5586 return VOS_STATUS_E_NOMEM;
5587 }
5588 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5589 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5590 pGetRoamRssiRspParams->rssi = 0;
5591 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5592 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5593 (void *)pGetRoamRssiRspParams, 0) ;
5594 }
5595 return CONVERT_WDI2VOS_STATUS(status);
5596}
5597#endif
5598
5599
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5600/*
5601 * FUNCTION: WDA_UpdateEDCAParamCallback
5602 * call back function for Update EDCA params from WDI
5603 */
5604void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5605{
5606 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5607 tEdcaParams *pEdcaParams;
5608
5609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5610 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5611 if(NULL == pWdaParams)
5612 {
5613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5614 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5615 VOS_ASSERT(0) ;
5616 return ;
5617 }
5618 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5619 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5620 vos_mem_free(pWdaParams);
5621 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5622 return ;
5623}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5624/*
5625 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5626 * Request to WDI to Update the EDCA params.
5627 */
5628VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5629 tEdcaParams *pEdcaParams)
5630{
5631 WDI_Status status = WDI_STATUS_SUCCESS ;
5632 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5633 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5634 sizeof(WDI_UpdateEDCAParamsType)) ;
5635 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5637 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5638 if(NULL == wdiEdcaParam)
5639 {
5640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5641 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5642 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5643 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5644 return VOS_STATUS_E_NOMEM;
5645 }
5646 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5647 if(NULL == pWdaParams)
5648 {
5649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5650 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5651 VOS_ASSERT(0);
5652 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5653 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5654 return VOS_STATUS_E_NOMEM;
5655 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5656 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5657 /*
5658 Since firmware is not using highperformance flag, we have removed
5659 this flag from wdiEDCAInfo structure to match sizeof the structure
5660 between host and firmware.In future if we are planning to use
5661 highperformance flag then Please define this flag in wdiEDCAInfo
5662 structure, update it here and send it to firmware. i.e.
5663 Following is the original line which we removed as part of the fix
5664 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5665 pEdcaParams->highPerformance;
5666 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5667 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5668 &pEdcaParams->acbe);
5669 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5670 &pEdcaParams->acbk);
5671 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5672 &pEdcaParams->acvi);
5673 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5674 &pEdcaParams->acvo);
5675 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5676 pWdaParams->pWdaContext = pWDA;
5677 /* Store remove key pointer, as this will be used for response */
5678 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5679 /* store Params pass it to WDI */
5680 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5681 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5682 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5683 if(IS_WDI_STATUS_FAILURE(status))
5684 {
5685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5686 "Failure in Update EDCA Params WDI API, free all the memory " );
5687 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5688 vos_mem_free(pWdaParams);
5689 vos_mem_free(pEdcaParams);
5690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5691 return CONVERT_WDI2VOS_STATUS(status) ;
5692}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5693/*
5694 * FUNCTION: WDA_AddBAReqCallback
5695 * send ADD BA RSP back to PE
5696 */
5697void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5698 void* pUserData)
5699{
5700 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5701 tWDA_CbContext *pWDA;
5702 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5704 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5705 if(NULL == pWdaParams)
5706 {
5707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5708 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5709 VOS_ASSERT(0) ;
5710 return ;
5711 }
5712 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5713 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5714 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5715 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5716 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5717 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5718 return ;
5719}
5720
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5721/*
5722 * FUNCTION: WDA_ProcessAddBAReq
5723 * Request to WDI to Update the ADDBA REQ params.
5724 */
5725VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5726 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5727{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5728 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5729 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5730 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5731 sizeof(WDI_AddBAReqParamsType)) ;
5732 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5734 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5735 if(NULL == wdiAddBAReqParam)
5736 {
5737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5738 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5739 VOS_ASSERT(0);
5740 return VOS_STATUS_E_NOMEM;
5741 }
5742 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5743 if(NULL == pWdaParams)
5744 {
5745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5746 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5747 VOS_ASSERT(0);
5748 vos_mem_free(wdiAddBAReqParam);
5749 return VOS_STATUS_E_NOMEM;
5750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5751 do
5752 {
5753 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5754 wdiAddBaInfo->ucSTAIdx = staIdx ;
5755 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5756 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5757 } while(0) ;
5758 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5759 pWdaParams->pWdaContext = pWDA;
5760 /* store Params pass it to WDI */
5761 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5762 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5763 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5764 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5765
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5766 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5767 {
5768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5769 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5770 status = CONVERT_WDI2VOS_STATUS(wstatus);
5771 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5772 vos_mem_free(pWdaParams);
5773 pAddBAReqParams->status = eSIR_FAILURE;
5774 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5775 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5776 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5777}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5778/*
5779 * FUNCTION: WDA_AddBASessionReqCallback
5780 * send ADD BA SESSION RSP back to PE/(or TL)
5781 */
5782void WDA_AddBASessionReqCallback(
5783 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
5784{
5785 VOS_STATUS status = VOS_STATUS_SUCCESS ;
5786 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5787 tWDA_CbContext *pWDA;
5788 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5790 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5791 if(NULL == pWdaParams)
5792 {
5793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5794 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5795 VOS_ASSERT(0) ;
5796 return ;
5797 }
5798 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5799 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5800 if( NULL == pAddBAReqParams )
5801 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5803 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5804 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5805 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5806 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5807 return ;
5808 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5809 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5810 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5811 /*
5812 * if WDA in update TL state, update TL with BA session parama and send
5813 * another request to HAL(/WDI) (ADD_BA_REQ)
5814 */
5815
5816 if((VOS_STATUS_SUCCESS ==
5817 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
5818 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
5819 {
5820 /* Update TL with BA info received from HAL/WDI */
5821 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
5822 wdiAddBaSession->usBaSessionID,
5823 wdiAddBaSession->ucSTAIdx,
5824 wdiAddBaSession->ucBaTID,
5825 wdiAddBaSession->ucBaBufferSize,
5826 wdiAddBaSession->ucWinSize,
5827 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5828 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
5829 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
5830 }
5831 else
5832 {
5833 pAddBAReqParams->status =
5834 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
5835
5836 /* Setting Flag to indicate that Set BA is success */
5837 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
5838 {
5839 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
5840 tANI_U8 tid = wdiAddBaSession->ucBaTID;
5841 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
5842 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5843 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5844 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5845 /*Reset the WDA state to READY */
5846 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5847 return ;
5848}
5849
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5850/*
5851 * FUNCTION: WDA_ProcessAddBASessionReq
5852 * Request to WDI to Update the ADDBA REQ params.
5853 */
5854VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
5855 tAddBAParams *pAddBAReqParams)
5856{
5857 WDI_Status status = WDI_STATUS_SUCCESS ;
5858 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
5859 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
5860 sizeof(WDI_AddBASessionReqParamsType)) ;
5861 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5862 WLANTL_STAStateType tlSTAState = 0;
5863
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5865 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5866 if(NULL == wdiAddBASessionReqParam)
5867 {
5868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5869 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5870 VOS_ASSERT(0);
5871 return VOS_STATUS_E_NOMEM;
5872 }
5873 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5874 if(NULL == pWdaParams)
5875 {
5876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5877 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5878 VOS_ASSERT(0);
5879 vos_mem_free(wdiAddBASessionReqParam);
5880 return VOS_STATUS_E_NOMEM;
5881 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5882 /*
5883 * Populate ADD BA parameters and pass these paarmeters to WDI.
5884 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
5885 * the state to track if these is BA recipient case or BA initiator
5886 * case.
5887 */
5888 do
5889 {
5890 WDI_AddBASessionReqinfoType *wdiBAInfoType =
5891 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
5892 /* vos_mem_copy(wdiBAInfoType->macBSSID,
5893 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
5894 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
5895 vos_mem_copy(wdiBAInfoType->macPeerAddr,
5896 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5897 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5898 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
5899 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
5900 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
5901 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
5902 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5903 /* check the BA direction and update state accordingly */
5904 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
5905 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
5906 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
5907
5908 }while(0) ;
5909 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5910 pWdaParams->pWdaContext = pWDA;
5911 /* Store ADD BA pointer, as this will be used for response */
5912 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
5913 /* store Params pass it to WDI */
5914 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5915
5916 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
5917 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
5918 */
5919 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
5920 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
5921 {
5922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5923 "Peer staIdx %d hasn't established yet(%d). Send ADD BA failure to PE.", pAddBAReqParams->staIdx, tlSTAState );
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5924 status = WDI_STATUS_E_NOT_ALLOWED;
5925 pAddBAReqParams->status =
5926 CONVERT_WDI2SIR_STATUS(status) ;
5927 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5928 /*Reset the WDA state to READY */
5929 pWDA->wdaState = WDA_READY_STATE;
5930 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5931 vos_mem_free(pWdaParams);
5932
5933 return CONVERT_WDI2VOS_STATUS(status) ;
5934 }
5935
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5936 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
5937 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5938 if(IS_WDI_STATUS_FAILURE(status))
5939 {
5940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5941 "Failure in ADD BA Session REQ Params WDI API, free all the memory =%d", status);
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]5942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5943 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]5944 pAddBAReqParams->status =
5945 CONVERT_WDI2SIR_STATUS(status) ;
5946 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5947 /*Reset the WDA state to READY */
5948 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5949 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5950 vos_mem_free(pWdaParams);
5951 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5952 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5953}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5954/*
5955 * FUNCTION: WDA_DelBANotifyTL
5956 * send DEL BA IND to TL
5957 */
5958void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
5959 tDelBAParams *pDelBAReqParams)
5960{
5961 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
5962 //tSirMsgQ msg;
5963 vos_msg_t vosMsg;
5964 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5965 if(NULL == pDelBAInd)
5966 {
5967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5968 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5969 VOS_ASSERT(0) ;
5970 return;
5971 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5972 pDelBAInd->mesgType = WDA_DELETEBA_IND;
5973 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
5974 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
5975 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5976
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5977
5978 vosMsg.type = WDA_DELETEBA_IND;
5979 vosMsg.bodyptr = pDelBAInd;
5980 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
5981 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
5982 {
5983 vosStatus = VOS_STATUS_E_BADMSG;
5984 }
5985}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5986/*
5987 * FUNCTION: WDA_DelBAReqCallback
5988 * send DEL BA RSP back to PE
5989 */
5990void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
5991{
5992 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5993 tWDA_CbContext *pWDA;
5994 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5996 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5997 if(NULL == pWdaParams)
5998 {
5999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6000 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6001 VOS_ASSERT(0) ;
6002 return ;
6003 }
6004 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6005 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6006 /* Notify TL about DEL BA in case of recipinet */
6007 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6008 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6009 {
6010 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6011 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6012 /*
6013 * No respone required for WDA_DELBA_IND so just free the request
6014 * param here
6015 */
6016 vos_mem_free(pDelBAReqParams);
6017 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6018 vos_mem_free(pWdaParams);
6019 return ;
6020}
6021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6022/*
6023 * FUNCTION: WDA_ProcessDelBAReq
6024 * Request to WDI to Update the DELBA REQ params.
6025 */
6026VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6027 tDelBAParams *pDelBAReqParams)
6028{
6029 WDI_Status status = WDI_STATUS_SUCCESS ;
6030 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6031 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6032 sizeof(WDI_DelBAReqParamsType)) ;
6033 tWDA_ReqParams *pWdaParams ;
6034 tANI_U16 staIdx = 0;
6035 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6037 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6038 if(NULL == wdiDelBAReqParam)
6039 {
6040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6042 VOS_ASSERT(0);
6043 return VOS_STATUS_E_NOMEM;
6044 }
6045 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6046 if(NULL == pWdaParams)
6047 {
6048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6049 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6050 VOS_ASSERT(0);
6051 vos_mem_free(wdiDelBAReqParam);
6052 return VOS_STATUS_E_NOMEM;
6053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6054 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6055 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6056 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6057 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6058 pWdaParams->pWdaContext = pWDA;
6059 /* Store DEL BA pointer, as this will be used for response */
6060 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6061 /* store Params pass it to WDI */
6062 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6063 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6064 * maintained in WDA, so that WDA can retry for another BA session
6065 */
6066 staIdx = pDelBAReqParams->staIdx;
6067 tid = pDelBAReqParams->baTID;
6068 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6069 status = WDI_DelBAReq(wdiDelBAReqParam,
6070 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6071 if(IS_WDI_STATUS_FAILURE(status))
6072 {
6073 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6074 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6075 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6076 vos_mem_free(pWdaParams->wdaMsgParam);
6077 vos_mem_free(pWdaParams);
6078 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6079 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6080}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6081
6082/*
6083 * FUNCTION: WDA_UpdateChReqCallback
6084 *
6085 */
6086void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6087{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6088 tWDA_ReqParams *pWdaParams;
6089 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6090 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6091 WDI_UpdateChannelReqinfoType *pChanInfoType;
6092 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6093
6094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6095 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6096 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6097 {
6098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6099 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6100 VOS_ASSERT(0);
6101 return;
6102 }
6103
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6104 pWdaParams = (tWDA_ReqParams *)pUserData;
6105 pwdiUpdateChReqParam =
6106 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6107 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6108 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6109 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6110 /*
6111 * currently there is no response message is expected between PE and
6112 * WDA, Failure return from WDI is a ASSERT condition
6113 */
6114 vos_mem_free(pChanInfoType);
6115 vos_mem_free(pChanList);
6116 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6117 vos_mem_free(pWdaParams);
6118
6119 return;
6120}
6121
6122/*
6123 * FUNCTION: WDA_ProcessUpdateChannelList
6124 * Request to WDI to Update the ChannelList params.
6125 */
6126VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6127 tSirUpdateChanList *pChanList)
6128{
6129 WDI_Status status = WDI_STATUS_SUCCESS;
6130 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6131 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6132 WDI_UpdateChannelReqinfoType *pChanInfoType;
6133 tWDA_ReqParams *pWdaParams;
6134 wpt_uint8 i;
6135
6136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6137 "------> %s " ,__func__);
6138 if(NULL == pChanList)
6139 {
6140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6141 "%s: NULL pChanList", __func__);
6142 VOS_ASSERT(0);
6143 return VOS_STATUS_E_INVAL;
6144 }
6145
6146 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6147 {
6148 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6149 "Update channel list capability Not Supported");
6150 vos_mem_free(pChanList);
6151 return VOS_STATUS_E_INVAL;
6152 }
6153
6154 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6155 sizeof(WDI_UpdateChReqParamsType));
6156 if(NULL == pwdiUpdateChReqParam)
6157 {
6158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6159 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6160 __func__);
6161 VOS_ASSERT(0);
6162 vos_mem_free(pChanList);
6163 return VOS_STATUS_E_NOMEM;
6164 }
6165 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6166 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6167 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6168 pChanList->numChan);
6169 if(NULL == pChanInfoType)
6170 {
6171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6172 "%s: VOS MEM Alloc Failure", __func__);
6173 VOS_ASSERT(0);
6174 vos_mem_free(pChanList);
6175 vos_mem_free(pwdiUpdateChReqParam);
6176 return VOS_STATUS_E_NOMEM;
6177 }
6178 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6179 * pChanList->numChan);
6180 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6181
6182 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6183 if(NULL == pWdaParams)
6184 {
6185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6186 "%s: VOS MEM Alloc Failure", __func__);
6187 VOS_ASSERT(0);
6188 vos_mem_free(pChanList);
6189 vos_mem_free(pChanInfoType);
6190 vos_mem_free(pwdiUpdateChReqParam);
6191 return VOS_STATUS_E_NOMEM;
6192 }
6193 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6194
6195 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6196 {
6197 pChanInfoType->mhz =
6198 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6199
6200 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6201 pChanInfoType->band_center_freq2 = 0;
6202
6203 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6204 "chan[%d] = %u", i, pChanInfoType->mhz);
6205 if (pChanList->chanParam[i].dfsSet)
6206 {
6207 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6209 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6210 pChanList->chanParam[i].dfsSet);
6211 }
6212
6213 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6214 {
6215 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6216 }
6217 else
6218 {
6219 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6220 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6221 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6222 }
6223
6224 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6225 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6226
6227 pChanInfoType++;
6228 }
6229
6230 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6231 pWdaParams->pWdaContext = pWDA;
6232 pWdaParams->wdaMsgParam = (void *)pChanList;
6233 /* store Params pass it to WDI */
6234 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6235 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6236 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6237 if(IS_WDI_STATUS_FAILURE(status))
6238 {
6239 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6240 "Failure in Update Channel REQ Params WDI API, free all the memory");
6241 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6242 vos_mem_free(pwdiUpdateChReqParam);
6243 vos_mem_free(pWdaParams->wdaMsgParam);
6244 vos_mem_free(pWdaParams);
6245 }
6246 return CONVERT_WDI2VOS_STATUS(status);
6247}
6248
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6249/*
6250 * FUNCTION: WDA_AddTSReqCallback
6251 * send ADD TS RSP back to PE
6252 */
6253void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6254{
6255 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6256 tWDA_CbContext *pWDA;
6257 tAddTsParams *pAddTsReqParams;
6258
6259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6260 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6261 if(NULL == pWdaParams)
6262 {
6263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6264 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6265 VOS_ASSERT(0) ;
6266 return ;
6267 }
6268 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6269 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6270 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6271 vos_mem_free(pWdaParams);
6272
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6273 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6274 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6275 return ;
6276}
6277
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6278/*
6279 * FUNCTION: WDA_ProcessAddTSReq
6280 * Request to WDI to Update the ADD TS REQ params.
6281 */
6282VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6283 tAddTsParams *pAddTsReqParams)
6284{
6285 WDI_Status status = WDI_STATUS_SUCCESS ;
6286 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6287 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6288 sizeof(WDI_AddTSReqParamsType)) ;
6289 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6291 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6292 if(NULL == wdiAddTSReqParam)
6293 {
6294 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6295 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6296 VOS_ASSERT(0);
6297 return VOS_STATUS_E_NOMEM;
6298 }
6299 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6300 if(NULL == pWdaParams)
6301 {
6302 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6303 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6304 VOS_ASSERT(0);
6305 vos_mem_free(wdiAddTSReqParam);
6306 return VOS_STATUS_E_NOMEM;
6307 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6308 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6309 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6310 //TS IE
6311 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6312 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6313 pAddTsReqParams->tspec.length;
6314
6315 //TS IE : TS INFO : TRAFFIC
6316 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6317 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6318 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6319 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6320 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6321 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6322 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6323 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6324 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6325 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6326 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6327 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6328 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6329 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6330 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6331 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6332
6333 //TS IE : TS INFO : SCHEDULE
6334 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6335 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6336 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6337 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6338 //TS IE
6339 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6340 pAddTsReqParams->tspec.nomMsduSz;
6341 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6342 pAddTsReqParams->tspec.maxMsduSz;
6343 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6344 pAddTsReqParams->tspec.minSvcInterval;
6345 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6346 pAddTsReqParams->tspec.maxSvcInterval;
6347 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6348 pAddTsReqParams->tspec.inactInterval;
6349 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6350 pAddTsReqParams->tspec.suspendInterval;
6351 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6352 pAddTsReqParams->tspec.svcStartTime;
6353 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6354 pAddTsReqParams->tspec.minDataRate;
6355 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6356 pAddTsReqParams->tspec.meanDataRate;
6357 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6358 pAddTsReqParams->tspec.peakDataRate;
6359 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6360 pAddTsReqParams->tspec.maxBurstSz;
6361 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6362 pAddTsReqParams->tspec.delayBound;
6363 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6364 pAddTsReqParams->tspec.minPhyRate;
6365 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6366 pAddTsReqParams->tspec.surplusBw;
6367 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6368 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6369 /* TODO: tAddTsParams doesn't have the following fields */
6370#if 0
6371 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6372 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6373 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6374 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6375#endif
6376 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6377
6378 pWdaParams->pWdaContext = pWDA;
6379 /* Store ADD TS pointer, as this will be used for response */
6380 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6381 /* store Params pass it to WDI */
6382 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6383 status = WDI_AddTSReq(wdiAddTSReqParam,
6384 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6385 if(IS_WDI_STATUS_FAILURE(status))
6386 {
6387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6388 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6389 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6390 vos_mem_free(pWdaParams);
6391 pAddTsReqParams->status = eSIR_FAILURE ;
6392 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6393 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6394 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6395}
6396
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6397/*
6398 * FUNCTION: WDA_DelTSReqCallback
6399 * send DEL TS RSP back to PE
6400 */
6401void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6402{
6403 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6405 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6406 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6407 vos_mem_free(pWdaParams->wdaMsgParam) ;
6408 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6409 /*
6410 * No respone required for WDA_DEL_TS_REQ so just free the request
6411 * param here
6412 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6413 return ;
6414}
6415
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6416/*
6417 * FUNCTION: WDA_ProcessDelTSReq
6418 * Request to WDI to Update the DELTS REQ params.
6419 */
6420VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6421 tDelTsParams *pDelTSReqParams)
6422{
6423 WDI_Status status = WDI_STATUS_SUCCESS ;
6424 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6425 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6426 sizeof(WDI_DelTSReqParamsType)) ;
6427 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6429 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6430 if(NULL == wdiDelTSReqParam)
6431 {
6432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6433 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6434 VOS_ASSERT(0);
6435 return VOS_STATUS_E_NOMEM;
6436 }
6437 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6438 if(NULL == pWdaParams)
6439 {
6440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6441 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6442 VOS_ASSERT(0);
6443 vos_mem_free(wdiDelTSReqParam);
6444 return VOS_STATUS_E_NOMEM;
6445 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6446 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6447 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6448 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6449 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6450 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6451 pWdaParams->pWdaContext = pWDA;
6452 /* Store DEL TS pointer, as this will be used for response */
6453 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6454 /* store Params pass it to WDI */
6455 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6456 status = WDI_DelTSReq(wdiDelTSReqParam,
6457 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6458 if(IS_WDI_STATUS_FAILURE(status))
6459 {
6460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6461 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6463 vos_mem_free(pWdaParams->wdaMsgParam);
6464 vos_mem_free(pWdaParams);
6465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6466 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6467}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6468/*
6469 * FUNCTION: WDA_UpdateBeaconParamsCallback
6470 * Free the memory. No need to send any response to PE in this case
6471 */
6472void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6473{
6474 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6476 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6477 if(NULL == pWdaParams)
6478 {
6479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6480 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6481 VOS_ASSERT(0) ;
6482 return ;
6483 }
6484 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6485 vos_mem_free(pWdaParams->wdaMsgParam) ;
6486 vos_mem_free(pWdaParams);
6487 /*
6488 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6489 * param here
6490 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6491 return ;
6492}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6493/*
6494 * FUNCTION: WDA_ProcessUpdateBeaconParams
6495 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6496 */
6497VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6498 tUpdateBeaconParams *pUpdateBeaconParams)
6499{
6500 WDI_Status status = WDI_STATUS_SUCCESS ;
6501 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6502 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6503 sizeof(WDI_UpdateBeaconParamsType)) ;
6504 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6506 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6507 if(NULL == wdiUpdateBeaconParams)
6508 {
6509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6510 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6511 VOS_ASSERT(0);
6512 return VOS_STATUS_E_NOMEM;
6513 }
6514 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6515 if(NULL == pWdaParams)
6516 {
6517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6518 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6519 VOS_ASSERT(0);
6520 vos_mem_free(wdiUpdateBeaconParams);
6521 return VOS_STATUS_E_NOMEM;
6522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6523 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6524 pUpdateBeaconParams->bssIdx;
6525 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6526 pUpdateBeaconParams->fShortPreamble;
6527 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6528 pUpdateBeaconParams->fShortSlotTime;
6529 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6530 pUpdateBeaconParams->beaconInterval;
6531 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6532 pUpdateBeaconParams->llaCoexist;
6533 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6534 pUpdateBeaconParams->llbCoexist;
6535 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6536 pUpdateBeaconParams->llgCoexist;
6537 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6538 pUpdateBeaconParams->ht20MhzCoexist;
6539 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6540 pUpdateBeaconParams->llnNonGFCoexist;
6541 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6542 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6543 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6544 pUpdateBeaconParams->fRIFSMode;
6545 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6546 pUpdateBeaconParams->paramChangeBitmap;
6547 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6548
6549 pWdaParams->pWdaContext = pWDA;
6550 /* Store UpdateBeacon Req pointer, as this will be used for response */
6551 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6552 /* store Params pass it to WDI */
6553 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6554 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6555 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6556 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6557 if(IS_WDI_STATUS_FAILURE(status))
6558 {
6559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6560 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6561 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6562 vos_mem_free(pWdaParams->wdaMsgParam);
6563 vos_mem_free(pWdaParams);
6564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6565 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6566}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6567#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6568/*
6569 * FUNCTION: WDA_TSMStatsReqCallback
6570 * send TSM Stats RSP back to PE
6571 */
6572void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6573{
6574 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6575 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6576 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6577 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6578
6579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6580 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6581 if(NULL == pWdaParams)
6582 {
6583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6584 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6585 VOS_ASSERT(0) ;
6586 return ;
6587 }
6588 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6589 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6590
6591 if(NULL == pGetTsmStatsReqParams)
6592 {
6593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6594 "%s: pGetTsmStatsReqParams received NULL", __func__);
6595 VOS_ASSERT(0);
6596 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6597 vos_mem_free(pWdaParams);
6598 return;
6599 }
6600
6601 pTsmRspParams =
6602 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6603 if( NULL == pTsmRspParams )
6604 {
6605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6606 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6607 VOS_ASSERT( 0 );
6608 return ;
6609 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6610 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6611 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6612 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6613
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6614 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6615 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6616 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6617 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6618 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6619 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6620 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6621 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6622 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6623 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6624
6625 /* Assign get tsm stats req req (backup) in to the response */
6626 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6627
6628 /* free WDI command buffer */
6629 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6630 vos_mem_free(pWdaParams);
6631
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6632 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6633 return ;
6634}
6635
6636
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6637/*
6638 * FUNCTION: WDA_ProcessTsmStatsReq
6639 * Request to WDI to get the TSM Stats params.
6640 */
6641VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6642 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6643{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6644 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6645 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6646 tWDA_ReqParams *pWdaParams = NULL;
6647 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6648
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6650 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6651 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6652 sizeof(WDI_TSMStatsReqParamsType));
6653 if(NULL == wdiTSMReqParam)
6654 {
6655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6656 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6657 VOS_ASSERT(0);
6658 return VOS_STATUS_E_NOMEM;
6659 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6660 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6661 if(NULL == pWdaParams)
6662 {
6663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6664 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6665 VOS_ASSERT(0);
6666 vos_mem_free(wdiTSMReqParam);
6667 return VOS_STATUS_E_NOMEM;
6668 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6669 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6670 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6671 pTsmStats->bssId,
6672 sizeof(wpt_macAddr));
6673 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6674
6675 pWdaParams->pWdaContext = pWDA;
6676 /* Store TSM Stats pointer, as this will be used for response */
6677 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6678 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6679 status = WDI_TSMStatsReq(wdiTSMReqParam,
6680 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6681 if(IS_WDI_STATUS_FAILURE(status))
6682 {
6683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6684 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6685 vos_mem_free(pWdaParams);
6686
6687 pGetTsmStatsRspParams =
6688 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6689 if(NULL == pGetTsmStatsRspParams)
6690 {
6691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6692 "%s: VOS MEM Alloc Failure", __func__);
6693 VOS_ASSERT(0);
6694 vos_mem_free(pTsmStats);
6695 return VOS_STATUS_E_NOMEM;
6696 }
6697 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6698 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6699 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6700
6701 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6702 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6703 return CONVERT_WDI2VOS_STATUS(status) ;
6704}
6705#endif
6706/*
6707 * FUNCTION: WDA_SendBeaconParamsCallback
6708 * No need to send any response to PE in this case
6709 */
6710void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6711{
6712
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6714 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6715 return ;
6716}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6717/*
6718 * FUNCTION: WDA_ProcessSendBeacon
6719 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6720 * start beacon trasmission
6721 */
6722VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6723 tSendbeaconParams *pSendbeaconParams)
6724{
6725 WDI_Status status = WDI_STATUS_SUCCESS ;
6726 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6728 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6729 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6730 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6731 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6732 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6733 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6734 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6735 /* p2pIeOffset should be atleast greater than timIeOffset */
6736 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6737 (pSendbeaconParams->p2pIeOffset <
6738 pSendbeaconParams->timIeOffset))
6739 {
6740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6741 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6742 VOS_ASSERT( 0 );
6743 return WDI_STATUS_E_FAILURE;
6744 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6745 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6746 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6747 /* Copy the beacon template to local buffer */
6748 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6749 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6750 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6751
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6752 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6753 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6754 if(IS_WDI_STATUS_FAILURE(status))
6755 {
6756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6757 "Failure in SEND BEACON REQ Params WDI API" );
6758 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6759 vos_mem_free(pSendbeaconParams);
6760 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6761}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6762/*
6763 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6764 * No need to send any response to PE in this case
6765 */
6766void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6767{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6769 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6770 return ;
6771}
6772
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6773/*
6774 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6775 * Request to WDI to send the probe response template to HAL to update the TPE memory and
6776 * send probe response
6777 */
6778VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
6779 tSendProbeRespParams *pSendProbeRspParams)
6780{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6781 WDI_Status status = WDI_STATUS_SUCCESS;
6782 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
6783 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6785 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6786
6787 if (!wdiSendProbeRspParam)
6788 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
6789
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6790 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6791 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6792 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6793 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6794 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6795 /* Copy the Probe Response template to local buffer */
6796 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6797 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6798 pSendProbeRspParams->pProbeRespTemplate,
6799 pSendProbeRspParams->probeRespTemplateLen);
6800 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6801 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6802 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
6803 WDI_PROBE_REQ_BITMAP_IE_LEN);
6804
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6805 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6806
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6807 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6808 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6809 if(IS_WDI_STATUS_FAILURE(status))
6810 {
6811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6812 "Failure in SEND Probe RSP Params WDI API" );
6813 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6814 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6815 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6816 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6817}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6818#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6819/*
6820 * FUNCTION: WDA_SetMaxTxPowerCallBack
6821 * send the response to PE with power value received from WDI
6822 */
6823void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
6824 void* pUserData)
6825{
6826 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6827 tWDA_CbContext *pWDA = NULL;
6828 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
6829
6830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6831 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6832 if(NULL == pWdaParams)
6833 {
6834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6835 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6836 VOS_ASSERT(0) ;
6837 return ;
6838 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6839 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6840 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6841 if( NULL == pMaxTxPowerParams )
6842 {
6843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6844 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6845 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6846 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6847 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6848 return ;
6849 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6850
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6851
6852 /*need to free memory for the pointers used in the
6853 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6854 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6855 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6856 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6857
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6858
6859 /* send response to UMAC*/
6860 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
6861
6862 return;
6863}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6864/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6865 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6866 * Request to WDI to send set Max Tx Power Request
6867 */
6868 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
6869 tMaxTxPowerParams *MaxTxPowerParams)
6870{
6871 WDI_Status status = WDI_STATUS_SUCCESS;
6872 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
6873 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6874
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6876 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6877
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6878 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
6879 sizeof(WDI_SetMaxTxPowerParamsType));
6880 if(NULL == wdiSetMaxTxPowerParams)
6881 {
6882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6883 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884 VOS_ASSERT(0);
6885 return VOS_STATUS_E_NOMEM;
6886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6887 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6888 if(NULL == pWdaParams)
6889 {
6890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6891 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6892 vos_mem_free(wdiSetMaxTxPowerParams);
6893 VOS_ASSERT(0);
6894 return VOS_STATUS_E_NOMEM;
6895 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6896 /* Copy.Max.Tx.Power Params to WDI structure */
6897 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
6898 MaxTxPowerParams->bssId,
6899 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6900 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
6901 MaxTxPowerParams->selfStaMacAddr,
6902 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6903 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
6904 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6905 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6906 pWdaParams->pWdaContext = pWDA;
6907 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6908 /* store Params pass it to WDI */
6909 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6910 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
6911 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6912 if(IS_WDI_STATUS_FAILURE(status))
6913 {
6914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6915 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
6916 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6917 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6918 /* send response to UMAC*/
6919 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6920 }
6921 return CONVERT_WDI2VOS_STATUS(status);
6922
6923}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6924#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]6925
6926/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]6927 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
6928 * send the response to PE with power value received from WDI
6929 */
6930void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
6931 *pwdiSetMaxTxPowerPerBandRsp,
6932 void* pUserData)
6933{
6934 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6935 tWDA_CbContext *pWDA = NULL;
6936 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
6937
6938 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6939 "<------ %s ", __func__);
6940 if (NULL == pWdaParams)
6941 {
6942 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6943 "%s: pWdaParams received NULL", __func__);
6944 VOS_ASSERT(0);
6945 return ;
6946 }
6947 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6948 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
6949 if ( NULL == pMxTxPwrPerBandParams )
6950 {
6951 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6952 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
6953 VOS_ASSERT(0);
6954 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6955 vos_mem_free(pWdaParams);
6956 return;
6957 }
6958
6959 /*need to free memory for the pointers used in the
6960 WDA Process.Set Max Tx Power Req function*/
6961 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6962 vos_mem_free(pWdaParams);
6963 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
6964
6965 /* send response to UMAC*/
6966 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
6967 pMxTxPwrPerBandParams, 0);
6968
6969 return;
6970}
6971
6972/*
6973 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
6974 * Request to WDI to send set Max Tx Power Per band Request
6975 */
6976 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
6977 tMaxTxPowerPerBandParams
6978 *MaxTxPowerPerBandParams)
6979{
6980 WDI_Status status = WDI_STATUS_SUCCESS;
6981 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
6982 tWDA_ReqParams *pWdaParams = NULL;
6983
6984 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6985 "------> %s ", __func__);
6986
6987 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
6988 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
6989
6990 if (NULL == wdiSetMxTxPwrPerBandParams)
6991 {
6992 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6993 "%s: VOS MEM Alloc Failure", __func__);
6994 VOS_ASSERT(0);
6995 return VOS_STATUS_E_NOMEM;
6996 }
6997 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6998 if (NULL == pWdaParams)
6999 {
7000 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7001 "%s: VOS MEM Alloc Failure", __func__);
7002 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7003 VOS_ASSERT(0);
7004 return VOS_STATUS_E_NOMEM;
7005 }
7006 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7007 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7008 MaxTxPowerPerBandParams->bandInfo;
7009 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7010 MaxTxPowerPerBandParams->power;
7011 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7012 pWdaParams->pWdaContext = pWDA;
7013 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7014 /* store Params pass it to WDI */
7015 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7016 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7017 WDA_SetMaxTxPowerPerBandCallBack,
7018 pWdaParams);
7019 if (IS_WDI_STATUS_FAILURE(status))
7020 {
7021 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7022 "Failure in SET MAX TX Power REQ Params WDI API,"
7023 " free all the memory");
7024 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7025 vos_mem_free(pWdaParams);
7026 /* send response to UMAC*/
7027 WDA_SendMsg(pWDA,
7028 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7029 MaxTxPowerPerBandParams, 0);
7030 }
7031 return CONVERT_WDI2VOS_STATUS(status);
7032}
7033
7034/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7035 * FUNCTION: WDA_SetTxPowerCallBack
7036 * send the response to PE with power value received from WDI
7037 */
7038void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7039 void* pUserData)
7040{
7041 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7042 tWDA_CbContext *pWDA = NULL;
7043 tSirSetTxPowerReq *pTxPowerParams = NULL;
7044
7045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7046 "<------ %s ", __func__);
7047 if(NULL == pWdaParams)
7048 {
7049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7050 "%s: pWdaParams received NULL", __func__);
7051 VOS_ASSERT(0) ;
7052 return ;
7053 }
7054 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7055 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7056 if(NULL == pTxPowerParams)
7057 {
7058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7059 "%s: pTxPowerParams received NULL " ,__func__);
7060 VOS_ASSERT(0);
7061 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7062 vos_mem_free(pWdaParams);
7063 return ;
7064 }
7065
7066 /*need to free memory for the pointers used in the
7067 WDA Process.Set Max Tx Power Req function*/
7068 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7069 vos_mem_free(pWdaParams);
7070
7071 /* send response to UMAC*/
7072 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7073 return;
7074}
7075
7076/*
7077 * FUNCTION: WDA_ProcessSetTxPowerReq
7078 * Request to WDI to send set Tx Power Request
7079 */
7080 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7081 tSirSetTxPowerReq *txPowerParams)
7082{
7083 WDI_Status status = WDI_STATUS_SUCCESS;
7084 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7085 tWDA_ReqParams *pWdaParams = NULL;
7086
7087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7088 "------> %s ", __func__);
7089
7090 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7091 sizeof(WDI_SetTxPowerParamsType));
7092 if(NULL == wdiSetTxPowerParams)
7093 {
7094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7095 "%s: VOS MEM Alloc Failure", __func__);
7096 VOS_ASSERT(0);
7097 return VOS_STATUS_E_NOMEM;
7098 }
7099 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7100 if(NULL == pWdaParams)
7101 {
7102 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7103 "%s: VOS MEM Alloc Failure", __func__);
7104 vos_mem_free(wdiSetTxPowerParams);
7105 VOS_ASSERT(0);
7106 return VOS_STATUS_E_NOMEM;
7107 }
7108 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7109 txPowerParams->bssIdx;
7110 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7111 txPowerParams->mwPower;
7112 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7113 pWdaParams->pWdaContext = pWDA;
7114 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7115 /* store Params pass it to WDI */
7116 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7117 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7118 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7119 if(IS_WDI_STATUS_FAILURE(status))
7120 {
7121 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7122 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7123 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7124 vos_mem_free(pWdaParams);
7125 /* send response to UMAC*/
7126 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7127 }
7128 return CONVERT_WDI2VOS_STATUS(status);
7129}
7130
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7131/*
7132 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7133 * Free the memory. No need to send any response to PE in this case
7134 */
7135void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7136{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7137 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7140 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7141
7142 if(NULL == pWdaParams)
7143 {
7144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7145 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7146 VOS_ASSERT(0) ;
7147 return ;
7148 }
7149
7150 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7151 vos_mem_free(pWdaParams->wdaMsgParam) ;
7152 vos_mem_free(pWdaParams);
7153
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7154 /*
7155 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7156 * so just free the request param here
7157 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7158 return ;
7159}
7160
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7161/*
7162 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7163 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7164 */
7165VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7166 tP2pPsParams *pP2pPsConfigParams)
7167{
7168 WDI_Status status = WDI_STATUS_SUCCESS ;
7169 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7170 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7171 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7172 tWDA_ReqParams *pWdaParams = NULL;
7173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7175 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7176 if(NULL == wdiSetP2PGONOAReqParam)
7177 {
7178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7179 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7180 VOS_ASSERT(0);
7181 return VOS_STATUS_E_NOMEM;
7182 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7183
7184 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7185 if(NULL == pWdaParams)
7186 {
7187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7188 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7189 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7190 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7191 VOS_ASSERT(0);
7192 return VOS_STATUS_E_NOMEM;
7193 }
7194
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7195 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7196 pP2pPsConfigParams->opp_ps;
7197 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7198 pP2pPsConfigParams->ctWindow;
7199 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7200 pP2pPsConfigParams->count;
7201 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7202 pP2pPsConfigParams->duration;
7203 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7204 pP2pPsConfigParams->interval;
7205 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7206 pP2pPsConfigParams->single_noa_duration;
7207 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7208 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7209
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7210 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7211 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7212 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7214 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7215 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7216 pWdaParams->pWdaContext = pWDA;
7217
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7218 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7219 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7220
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7221 if(IS_WDI_STATUS_FAILURE(status))
7222 {
7223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7224 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7225 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7226 vos_mem_free(pWdaParams->wdaMsgParam);
7227 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7228 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7229 return CONVERT_WDI2VOS_STATUS(status);
7230
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7231}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7232
7233#ifdef FEATURE_WLAN_TDLS
7234/*
7235 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7236 * Free the memory. No need to send any response to PE in this case
7237 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7238void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7239 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7240{
7241 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7242 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7243 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7244
7245
7246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7247 "<------ %s " ,__func__);
7248 if(NULL == pWdaParams)
7249 {
7250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7251 "%s: pWdaParams received NULL", __func__);
7252 VOS_ASSERT(0) ;
7253 return ;
7254 }
7255 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7256
7257 if(NULL == pWdaParams)
7258 {
7259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7260 "%s: pWdaParams received NULL", __func__);
7261 VOS_ASSERT(0) ;
7262 return ;
7263 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7264 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7265 if( NULL == pTdlsLinkEstablishParams )
7266 {
7267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7268 "%s: pTdlsLinkEstablishParams "
7269 "received NULL " ,__func__);
7270 VOS_ASSERT(0);
7271 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7272 vos_mem_free(pWdaParams);
7273 return ;
7274 }
7275 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7276 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7277 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7278 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7279 /* send response to UMAC*/
7280 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7281
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7282 return ;
7283}
7284
7285VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7286 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7287{
7288 WDI_Status status = WDI_STATUS_SUCCESS ;
7289 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7290 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7291 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7292 tWDA_ReqParams *pWdaParams = NULL;
7293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7294 "------> %s " ,__func__);
7295 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7296 {
7297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7298 "%s: VOS MEM Alloc Failure", __func__);
7299 VOS_ASSERT(0);
7300 return VOS_STATUS_E_NOMEM;
7301 }
7302 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7303 if(NULL == pWdaParams)
7304 {
7305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7306 "%s: VOS MEM Alloc Failure", __func__);
7307 vos_mem_free(pTdlsLinkEstablishParams);
7308 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7309 VOS_ASSERT(0);
7310 return VOS_STATUS_E_NOMEM;
7311 }
7312 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7313 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7314 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7315 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7316 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7317 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7318 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7319 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7320 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7321 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7322 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7323 pTdlsLinkEstablishParams->isOffChannelSupported;
7324
7325 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7326 pTdlsLinkEstablishParams->validChannels,
7327 pTdlsLinkEstablishParams->validChannelsLen);
7328
7329 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7330 pTdlsLinkEstablishParams->validChannelsLen;
7331
7332 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7333 pTdlsLinkEstablishParams->validOperClasses,
7334 pTdlsLinkEstablishParams->validOperClassesLen);
7335 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7336 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7337
7338 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7339 /* Store msg pointer from PE, as this will be used for response */
7340 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7341 /* store Params pass it to WDI */
7342 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7343 pWdaParams->pWdaContext = pWDA;
7344
7345 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7346 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7347 WDA_SetTDLSLinkEstablishReqParamsCallback,
7348 pWdaParams);
7349 if(IS_WDI_STATUS_FAILURE(status))
7350 {
7351 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7352 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7353 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7354 vos_mem_free(pWdaParams->wdaMsgParam);
7355 vos_mem_free(pWdaParams);
7356 }
7357 return CONVERT_WDI2VOS_STATUS(status);
7358}
7359#endif
7360
7361
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7362#ifdef WLAN_FEATURE_VOWIFI_11R
7363/*
7364 * FUNCTION: WDA_AggrAddTSReqCallback
7365 * send ADD AGGREGATED TS RSP back to PE
7366 */
7367void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7368{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7369 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7370 tWDA_CbContext *pWDA;
7371 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7372 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7374 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7375 if(NULL == pWdaParams)
7376 {
7377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7378 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7379 VOS_ASSERT(0) ;
7380 return ;
7381 }
7382
7383 pWDA = pWdaParams->pWdaContext;
7384 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7385
7386 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7387 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7388 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7389 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7390 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7391
7392 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7393 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7394 return ;
7395}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7396/*
7397 * FUNCTION: WDA_ProcessAddTSReq
7398 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7399 */
7400VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7401 tAggrAddTsParams *pAggrAddTsReqParams)
7402{
7403 WDI_Status status = WDI_STATUS_SUCCESS ;
7404 int i;
7405 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7406 tWDA_ReqParams *pWdaParams = NULL;
7407
7408
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7410 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7411 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7412 sizeof(WDI_AggrAddTSReqParamsType)) ;
7413 if(NULL == wdiAggrAddTSReqParam)
7414 {
7415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7416 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7417 VOS_ASSERT(0);
7418 return VOS_STATUS_E_NOMEM;
7419 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7420
7421
7422 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7423 if(NULL == pWdaParams)
7424 {
7425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7426 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7427 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7428 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7429 VOS_ASSERT(0);
7430 return VOS_STATUS_E_NOMEM;
7431 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7432 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7433 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7434 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7435 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7436 {
7437 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7438 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7439 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7440 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7441 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7442 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7443 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7444 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7445 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7446 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7447 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7448 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7449 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7450 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7451 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7452 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7453 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7454 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7455 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7456 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7457 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7458 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7459 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7460 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7461 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7462 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7463 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7464 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7465 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7466 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7467 pAggrAddTsReqParams->tspec[i].inactInterval;
7468 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7469 pAggrAddTsReqParams->tspec[i].suspendInterval;
7470 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7471 pAggrAddTsReqParams->tspec[i].svcStartTime;
7472 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7473 pAggrAddTsReqParams->tspec[i].minDataRate;
7474 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7475 pAggrAddTsReqParams->tspec[i].meanDataRate;
7476 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7477 pAggrAddTsReqParams->tspec[i].peakDataRate;
7478 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7479 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7480 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7481 pAggrAddTsReqParams->tspec[i].delayBound;
7482 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7483 pAggrAddTsReqParams->tspec[i].minPhyRate;
7484 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7485 pAggrAddTsReqParams->tspec[i].surplusBw;
7486 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7487 pAggrAddTsReqParams->tspec[i].mediumTime;
7488 }
7489
7490 /* TODO: tAggrAddTsParams doesn't have the following fields */
7491#if 0
7492 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7493 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7494 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7495 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7496#endif
7497 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7498
7499 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7500 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7501 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7502 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7503
7504 pWdaParams->pWdaContext = pWDA;
7505
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7506 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7507 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7509 if(IS_WDI_STATUS_FAILURE(status))
7510 {
7511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7512 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7513 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7514 vos_mem_free(pWdaParams);
7515
7516 /* send the failure response back to PE*/
7517 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7518 {
7519 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7520 }
7521
7522 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7523 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7524 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7525 return CONVERT_WDI2VOS_STATUS(status) ;
7526}
7527#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7528/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7529 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7530 * send Enter IMPS RSP back to PE
7531 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7532void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7533{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7534 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7535 tWDA_CbContext *pWDA;
7536
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7538 "<------ %s status=%d" ,__func__,status);
7539 if(NULL == pWdaParams)
7540 {
7541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7542 "%s: pWdaParams received NULL", __func__);
7543 VOS_ASSERT(0);
7544 return;
7545 }
7546
7547 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7548
7549 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7550 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7551 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7552 return ;
7553}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7554
7555
7556/*
7557 * FUNCTION: WDA_EnterImpsReqCallback
7558 * Free memory and send Enter IMPS RSP back to PE.
7559 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7560 */
7561void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7562{
7563 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7564 tWDA_CbContext *pWDA;
7565
7566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7567 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7568
7569 if(NULL == pWdaParams)
7570 {
7571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7572 "%s: pWdaParams received NULL", __func__);
7573 VOS_ASSERT(0);
7574 return;
7575 }
7576
7577 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7578
7579 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7580 {
7581 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7582 vos_mem_free(pWdaParams);
7583 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7584 CONVERT_WDI2SIR_STATUS(wdiStatus));
7585 }
7586
7587 return;
7588}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7589/*
7590 * FUNCTION: WDA_ProcessEnterImpsReq
7591 * Request to WDI to Enter IMPS power state.
7592 */
7593VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7594{
7595 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7596 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7597 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7599 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7600
7601
7602 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7603 if (NULL == wdiEnterImpsReqParams)
7604 {
7605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7606 "%s: VOS MEM Alloc Failure", __func__);
7607 VOS_ASSERT(0);
7608 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7609 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7610 return VOS_STATUS_E_NOMEM;
7611 }
7612
7613 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7614 if (NULL == pWdaParams)
7615 {
7616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7617 "%s: VOS MEM Alloc Failure", __func__);
7618 VOS_ASSERT(0);
7619 vos_mem_free(wdiEnterImpsReqParams);
7620 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7621 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7622 return VOS_STATUS_E_NOMEM;
7623 }
7624
7625 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7626 wdiEnterImpsReqParams->pUserData = pWdaParams;
7627
7628 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7629 pWdaParams->wdaMsgParam = NULL;
7630 pWdaParams->pWdaContext = pWDA;
7631
7632 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7633 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7634 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7635 if(IS_WDI_STATUS_FAILURE(status))
7636 {
7637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7638 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7639 vos_mem_free(wdiEnterImpsReqParams);
7640 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7641 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7642 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7643 return CONVERT_WDI2VOS_STATUS(status) ;
7644}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7645/*
7646 * FUNCTION: WDA_ExitImpsReqCallback
7647 * send Exit IMPS RSP back to PE
7648 */
7649void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7650{
7651 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7653 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7654 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7655 return ;
7656}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7657/*
7658 * FUNCTION: WDA_ProcessExitImpsReq
7659 * Request to WDI to Exit IMPS power state.
7660 */
7661VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7662{
7663 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7665 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7666 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7667 if(IS_WDI_STATUS_FAILURE(status))
7668 {
7669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7670 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7671 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7672 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7673 return CONVERT_WDI2VOS_STATUS(status) ;
7674}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7675/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7676 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7677 * send Enter BMPS RSP back to PE
7678 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7679void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7680{
7681 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7682 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7683 tEnterBmpsParams *pEnterBmpsRspParams;
7684
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7686 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7687 if(NULL == pWdaParams)
7688 {
7689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7690 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7691 VOS_ASSERT(0) ;
7692 return ;
7693 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7694
7695 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7696 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7697
7698 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7699 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7700
7701 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7702 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7703 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
7704
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7705 return ;
7706}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7707/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7708 * FUNCTION: WDA_EnterBmpsReqCallback
7709 * Free memory and send Enter BMPS RSP back to PE.
7710 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
7711 */
7712void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7713{
7714 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7715 tWDA_CbContext *pWDA;
7716 tEnterBmpsParams *pEnterBmpsRspParams;
7717
7718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7719 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7720
7721 if(NULL == pWdaParams)
7722 {
7723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7724 "%s: pWdaParams received NULL", __func__);
7725 VOS_ASSERT(0);
7726 return;
7727 }
7728
7729 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7730 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7731 pEnterBmpsRspParams->status = wdiStatus;
7732
7733 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7734 {
7735 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7736 vos_mem_free(pWdaParams);
7737 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
7738 }
7739
7740 return;
7741}
7742/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7743 * FUNCTION: WDA_ProcessEnterBmpsReq
7744 * Request to WDI to Enter BMPS power state.
7745 */
7746VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
7747 tEnterBmpsParams *pEnterBmpsReqParams)
7748{
7749 WDI_Status status = WDI_STATUS_SUCCESS;
7750 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
7751 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7753 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7754 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
7755 {
7756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7757 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7758 VOS_ASSERT(0);
7759 return VOS_STATUS_E_FAILURE;
7760 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7761 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
7762 if (NULL == wdiEnterBmpsReqParams)
7763 {
7764 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7765 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7766 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7767 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7768 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7769 return VOS_STATUS_E_NOMEM;
7770 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7771 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7772 if (NULL == pWdaParams)
7773 {
7774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7775 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7776 VOS_ASSERT(0);
7777 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7778 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7779 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7780 return VOS_STATUS_E_NOMEM;
7781 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7782 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
7783 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
7784 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
7785 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7786 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7787 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
7788 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
7789 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7790 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
7791 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7792
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7793 /* Store param pointer as passed in by caller */
7794 /* store Params pass it to WDI */
7795 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7796 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7797 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7798 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7799 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7800 if (IS_WDI_STATUS_FAILURE(status))
7801 {
7802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7803 "Failure in Enter BMPS REQ WDI API, free all the memory" );
7804 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7805 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7806 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7807 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7808 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7809 return CONVERT_WDI2VOS_STATUS(status);
7810}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7811
7812
7813static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
7814 WDI_Status wdiStatus,
7815 tExitBmpsParams *pExitBmpsReqParams)
7816{
7817 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
7818
7819 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
7820}
7821
7822
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7823/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7824 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7825 * send Exit BMPS RSP back to PE
7826 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7827void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7828{
7829 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7830 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7831 tExitBmpsParams *pExitBmpsRspParams;
7832
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7834 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7835 if(NULL == pWdaParams)
7836 {
7837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7838 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7839 VOS_ASSERT(0) ;
7840 return ;
7841 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7842
7843 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7844 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7845
7846 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7847 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7848
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7849 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7850 vos_mem_free(pWdaParams) ;
7851
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7852 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7853 return ;
7854}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7855/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7856 * FUNCTION: WDA_ExitBmpsReqCallback
7857 * Free memory and send Exit BMPS RSP back to PE.
7858 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
7859 */
7860void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7861{
7862 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7863 tWDA_CbContext *pWDA;
7864 tExitBmpsParams *pExitBmpsRspParams;
7865
7866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7867 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7868
7869 if(NULL == pWdaParams)
7870 {
7871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7872 "%s: pWdaParams received NULL", __func__);
7873 VOS_ASSERT(0);
7874 return;
7875 }
7876
7877 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7878 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7879 pExitBmpsRspParams->status = wdiStatus;
7880
7881 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7882 {
7883 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7884 vos_mem_free(pWdaParams);
7885 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
7886 }
7887
7888 return;
7889}
7890/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7891 * FUNCTION: WDA_ProcessExitBmpsReq
7892 * Request to WDI to Exit BMPS power state.
7893 */
7894VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
7895 tExitBmpsParams *pExitBmpsReqParams)
7896{
7897 WDI_Status status = WDI_STATUS_SUCCESS ;
7898 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
7899 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
7900 sizeof(WDI_ExitBmpsReqParamsType)) ;
7901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7904 if(NULL == wdiExitBmpsReqParams)
7905 {
7906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7908 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7909 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7910 return VOS_STATUS_E_NOMEM;
7911 }
7912 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7913 if(NULL == pWdaParams)
7914 {
7915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7916 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7917 VOS_ASSERT(0);
7918 vos_mem_free(wdiExitBmpsReqParams);
7919 return VOS_STATUS_E_NOMEM;
7920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7921 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7922
7923 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
7924
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7925 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
7926 wdiExitBmpsReqParams->pUserData = pWdaParams;
7927
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7928 /* Store param pointer as passed in by caller */
7929 /* store Params pass it to WDI */
7930 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
7931 pWdaParams->pWdaContext = pWDA;
7932 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7933 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7934 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7935 if(IS_WDI_STATUS_FAILURE(status))
7936 {
7937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7938 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7939 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7940 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7941 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7942 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7943 return CONVERT_WDI2VOS_STATUS(status) ;
7944}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7945/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7946 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7947 * send Enter UAPSD RSP back to PE
7948 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7949void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7950{
7951 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7952 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7953 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7955 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7956 if(NULL == pWdaParams)
7957 {
7958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7959 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7960 VOS_ASSERT(0) ;
7961 return ;
7962 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7963
7964 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7965 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
7966
7967 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7968 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7969
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7971 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7972 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7973 return ;
7974}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7975/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7976 * FUNCTION: WDA_EnterUapsdReqCallback
7977 * Free memory and send Enter UAPSD RSP back to PE.
7978 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
7979 */
7980void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
7981{
7982 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7983 tWDA_CbContext *pWDA;
7984 tUapsdParams *pEnterUapsdRsqParams;
7985
7986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7987 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7988
7989 if(NULL == pWdaParams)
7990 {
7991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7992 "%s: pWdaParams received NULL", __func__);
7993 VOS_ASSERT(0);
7994 return;
7995 }
7996
7997 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7998 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
7999 pEnterUapsdRsqParams->status = wdiStatus;
8000
8001 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8002 {
8003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8004 vos_mem_free(pWdaParams);
8005 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8006 }
8007
8008 return;
8009}
8010/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8011 * FUNCTION: WDA_ProcessEnterUapsdReq
8012 * Request to WDI to Enter UAPSD power state.
8013 */
8014VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8015 tUapsdParams *pEnterUapsdReqParams)
8016{
8017 WDI_Status status = WDI_STATUS_SUCCESS ;
8018 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8019 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8020 sizeof(WDI_EnterUapsdReqParamsType)) ;
8021 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8023 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8024 if(NULL == wdiEnterUapsdReqParams)
8025 {
8026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8027 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8028 VOS_ASSERT(0);
8029 return VOS_STATUS_E_NOMEM;
8030 }
8031 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8032 if(NULL == pWdaParams)
8033 {
8034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8035 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8036 VOS_ASSERT(0);
8037 vos_mem_free(wdiEnterUapsdReqParams);
8038 return VOS_STATUS_E_NOMEM;
8039 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8040 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8041 pEnterUapsdReqParams->beDeliveryEnabled;
8042 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8043 pEnterUapsdReqParams->beTriggerEnabled;
8044 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8045 pEnterUapsdReqParams->bkDeliveryEnabled;
8046 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8047 pEnterUapsdReqParams->bkTriggerEnabled;
8048 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8049 pEnterUapsdReqParams->viDeliveryEnabled;
8050 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8051 pEnterUapsdReqParams->viTriggerEnabled;
8052 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8053 pEnterUapsdReqParams->voDeliveryEnabled;
8054 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8055 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8056 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8057
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8058 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8059 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8060
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8061 /* Store param pointer as passed in by caller */
8062 /* store Params pass it to WDI */
8063 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8064 pWdaParams->pWdaContext = pWDA;
8065 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8066 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8067 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8068 if(IS_WDI_STATUS_FAILURE(status))
8069 {
8070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8071 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8072 vos_mem_free(pWdaParams->wdaMsgParam) ;
8073 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8074 vos_mem_free(pWdaParams) ;
8075 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8076 return CONVERT_WDI2VOS_STATUS(status) ;
8077}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8078/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8079 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8080 * send Exit UAPSD RSP back to PE
8081 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8082void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8083{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8084
8085 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8086 tWDA_CbContext *pWDA;
8087 tExitUapsdParams *pExitUapsdRspParams;
8088
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8090 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8091 if(NULL == pWdaParams)
8092 {
8093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8094 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8095 VOS_ASSERT(0);
8096 return;
8097 }
8098
8099 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8100 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8101
8102 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8103 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8104
8105 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8106 vos_mem_free(pWdaParams) ;
8107
8108 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8109 return ;
8110}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8111/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8112 * FUNCTION: WDA_ExitUapsdReqCallback
8113 * Free memory and send Exit UAPSD RSP back to PE.
8114 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8115 */
8116void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8117{
8118 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8119 tWDA_CbContext *pWDA;
8120 tExitUapsdParams *pExitUapsdRspParams;
8121
8122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8123 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8124
8125 if(NULL == pWdaParams)
8126 {
8127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8128 "%s: pWdaParams received NULL", __func__);
8129 VOS_ASSERT(0);
8130 return;
8131 }
8132
8133 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8134 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8135 pExitUapsdRspParams->status = wdiStatus;
8136
8137 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8138 {
8139 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8140 vos_mem_free(pWdaParams);
8141 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8142 }
8143
8144 return;
8145}
8146/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8147 * FUNCTION: WDA_ProcessExitUapsdReq
8148 * Request to WDI to Exit UAPSD power state.
8149 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8150VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8151 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8152{
8153 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8154 tWDA_ReqParams *pWdaParams ;
8155 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8156 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8157 sizeof(WDI_ExitUapsdReqParamsType)) ;
8158
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8160 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8161
8162 if(NULL == wdiExitUapsdReqParams)
8163 {
8164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8165 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8166 VOS_ASSERT(0);
8167 return VOS_STATUS_E_NOMEM;
8168 }
8169 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8170 if(NULL == pWdaParams)
8171 {
8172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8173 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8174 VOS_ASSERT(0);
8175 vos_mem_free(wdiExitUapsdReqParams);
8176 return VOS_STATUS_E_NOMEM;
8177 }
8178
8179 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8180 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8181 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8182
8183 /* Store param pointer as passed in by caller */
8184 /* store Params pass it to WDI */
8185 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8186 pWdaParams->pWdaContext = pWDA;
8187 pWdaParams->wdaMsgParam = pExitUapsdParams;
8188
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8189 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8190 if(IS_WDI_STATUS_FAILURE(status))
8191 {
8192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8193 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8194 vos_mem_free(pWdaParams->wdaMsgParam) ;
8195 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8196 vos_mem_free(pWdaParams) ;
8197
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8198 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8199 return CONVERT_WDI2VOS_STATUS(status) ;
8200}
8201
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8202/*
8203 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8204 *
8205 */
8206void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8207{
8208 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8210 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8211 if(NULL == pWdaParams)
8212 {
8213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8214 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8215 VOS_ASSERT(0) ;
8216 return ;
8217 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8218 if( pWdaParams != NULL )
8219 {
8220 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8221 {
8222 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8223 }
8224 if( pWdaParams->wdaMsgParam != NULL )
8225 {
8226 vos_mem_free(pWdaParams->wdaMsgParam) ;
8227 }
8228 vos_mem_free(pWdaParams) ;
8229 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8230 return ;
8231}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8232/*
8233 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8234 * Request to WDI to set the power save params at start.
8235 */
8236VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8237 tSirPowerSaveCfg *pPowerSaveCfg)
8238{
8239 WDI_Status status = WDI_STATUS_SUCCESS ;
8240 tHalCfg *tlvStruct = NULL ;
8241 tANI_U8 *tlvStructStart = NULL ;
8242 v_PVOID_t *configParam;
8243 tANI_U32 configParamSize;
8244 tANI_U32 *configDataValue;
8245 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8246 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8248 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8249 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8250 {
8251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8252 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8253 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8254 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8255 return VOS_STATUS_E_FAILURE;
8256 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8257 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8258 if (NULL == wdiPowerSaveCfg)
8259 {
8260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8261 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8262 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8263 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8264 return VOS_STATUS_E_NOMEM;
8265 }
8266 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8267 if(NULL == pWdaParams)
8268 {
8269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8270 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8271 VOS_ASSERT(0);
8272 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8273 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8274 return VOS_STATUS_E_NOMEM;
8275 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8276 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8277 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8278 if(NULL == configParam)
8279 {
8280 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8281 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8282 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8283 vos_mem_free(pWdaParams);
8284 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8285 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8286 return VOS_STATUS_E_NOMEM;
8287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8288 vos_mem_set(configParam, configParamSize, 0);
8289 wdiPowerSaveCfg->pConfigBuffer = configParam;
8290 tlvStruct = (tHalCfg *)configParam;
8291 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8292 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8293 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8294 tlvStruct->length = sizeof(tANI_U32);
8295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8296 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8297 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8298 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8299 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8300 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8301 tlvStruct->length = sizeof(tANI_U32);
8302 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8303 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8304 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8305 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8306 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8307 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8308 tlvStruct->length = sizeof(tANI_U32);
8309 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8310 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8311 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8312 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8313 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8314 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8315 tlvStruct->length = sizeof(tANI_U32);
8316 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8317 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8318 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8319 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8320 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8321 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8322 tlvStruct->length = sizeof(tANI_U32);
8323 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8324 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8325 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8326 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8327 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8328 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8329 tlvStruct->length = sizeof(tANI_U32);
8330 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8331 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8332 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8333 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8334 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8335 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8336 tlvStruct->length = sizeof(tANI_U32);
8337 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8338 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8339 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8340 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8341 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8342 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8343 tlvStruct->length = sizeof(tANI_U32);
8344 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8345 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8346 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8347 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8348 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8349 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8350 tlvStruct->length = sizeof(tANI_U32);
8351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8352 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8353 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8354 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8355 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8356 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8357 tlvStruct->length = sizeof(tANI_U32);
8358 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8359 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8360 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8361 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8362 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8363 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8364 tlvStruct->length = sizeof(tANI_U32);
8365 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8366 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8367 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8368 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8369 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8370 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8371 /* store Params pass it to WDI */
8372 pWdaParams->wdaMsgParam = configParam;
8373 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8374 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8375 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8376 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8377 if(IS_WDI_STATUS_FAILURE(status))
8378 {
8379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8380 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8381 vos_mem_free(pWdaParams->wdaMsgParam);
8382 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8383 vos_mem_free(pWdaParams);
8384 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8385 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8386 return CONVERT_WDI2VOS_STATUS(status);
8387}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8388/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8389 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8390 *
8391 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8392void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8393{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8394 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8395
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8397 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8398
8399 if(NULL == pWdaParams)
8400 {
8401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8402 "%s: pWdaParams received NULL", __func__);
8403 VOS_ASSERT(0);
8404 return ;
8405 }
8406
8407 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8408 vos_mem_free(pWdaParams);
8409
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8410 return ;
8411}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8412/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8413 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8414 * Free memory.
8415 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8416 */
8417void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8418{
8419 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8420
8421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8422 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8423
8424 if(NULL == pWdaParams)
8425 {
8426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8427 "%s: pWdaParams received NULL", __func__);
8428 VOS_ASSERT(0);
8429 return;
8430 }
8431
8432 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8433 {
8434 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8435 vos_mem_free(pWdaParams);
8436 }
8437
8438 return;
8439}
8440/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8441 * FUNCTION: WDA_SetUapsdAcParamsReq
8442 * Request to WDI to set the UAPSD params for an ac (sta mode).
8443 */
8444VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8445 tUapsdInfo *pUapsdInfo)
8446{
8447 WDI_Status status = WDI_STATUS_SUCCESS;
8448 tWDA_CbContext *pWDA = NULL ;
8449 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8450 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8451 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8452 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8454 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8455 if(NULL == wdiUapsdParams)
8456 {
8457 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8458 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8459 VOS_ASSERT(0);
8460 return VOS_STATUS_E_NOMEM;
8461 }
8462 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8463 if(NULL == pWdaParams)
8464 {
8465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8466 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8467 VOS_ASSERT(0);
8468 vos_mem_free(wdiUapsdParams);
8469 return VOS_STATUS_E_NOMEM;
8470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8471 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8472 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8473 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8474 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8475 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8476 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8477 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8478 wdiUapsdParams->pUserData = pWdaParams;
8479
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8480 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8481 pWdaParams->pWdaContext = pWDA;
8482 /* Store param pointer as passed in by caller */
8483 pWdaParams->wdaMsgParam = pUapsdInfo;
8484 /* store Params pass it to WDI */
8485 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8486 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8487 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8488 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8489 if(IS_WDI_STATUS_FAILURE(status))
8490 {
8491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8492 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8493 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8494 vos_mem_free(pWdaParams);
8495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8496 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8497 return VOS_STATUS_SUCCESS;
8498 else
8499 return VOS_STATUS_E_FAILURE;
8500
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8501}
8502/*
8503 * FUNCTION: WDA_ClearUapsdAcParamsReq
8504 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8505 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8506 * and again enter the UPASD with the modified params. Hence the disable
8507 * function was kept empty.
8508 *
8509 */
8510VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8511{
8512 /* do nothing */
8513 return VOS_STATUS_SUCCESS;
8514}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8515/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8516 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8517 *
8518 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8519void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8520{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8521 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8522
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8524 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8525
8526 if(NULL == pWdaParams)
8527 {
8528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8529 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8530 VOS_ASSERT(0) ;
8531 return ;
8532 }
8533
8534 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8535 vos_mem_free(pWdaParams->wdaMsgParam);
8536 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8537
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8538 //print a msg, nothing else to do
8539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8540 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8541 return ;
8542}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8543/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8544 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8545 * Free memory.
8546 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8547 */
8548void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8549{
8550 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8551
8552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8553 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8554
8555 if(NULL == pWdaParams)
8556 {
8557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8558 "%s: pWdaParams received NULL", __func__);
8559 VOS_ASSERT(0);
8560 return;
8561 }
8562
8563 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8564 {
8565 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8566 vos_mem_free(pWdaParams->wdaMsgParam);
8567 vos_mem_free(pWdaParams);
8568 }
8569
8570 return;
8571}
8572/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8573 * FUNCTION: WDA_UpdateUapsdParamsReq
8574 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8575 */
8576VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8577 tUpdateUapsdParams* pUpdateUapsdInfo)
8578{
8579 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8580 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8581 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8582 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8583 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8584 tWDA_ReqParams *pWdaParams = NULL;
8585
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8587 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8588 if(NULL == wdiUpdateUapsdParams)
8589 {
8590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8591 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8592 VOS_ASSERT(0);
8593 return VOS_STATUS_E_NOMEM;
8594 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8595 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8596 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8597 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8598 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8599 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8600
8601 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8602 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8603 {
8604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8605 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8606 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8607 vos_mem_free(pUpdateUapsdInfo);
8608 vos_mem_free(wdiUpdateUapsdParams);
8609 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8610 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8611 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8612 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8613 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8614 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8615 pWdaParams->pWdaContext = pWDA;
8616
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8617 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8618 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8619 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8620
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8621 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8622 {
8623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8624 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8625 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8626 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8627 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8628 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8629 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8630 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8631}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8632/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8633 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8634 *
8635 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8636void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8637{
8638 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8639 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8640 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8641 if(WDI_STATUS_SUCCESS != wdiStatus)
8642 {
8643 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8644 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8645 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8646 if(NULL == pWdaParams)
8647 {
8648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8649 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8650 VOS_ASSERT(0) ;
8651 return ;
8652 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8653 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8654 vos_mem_free(pWdaParams->wdaMsgParam);
8655 vos_mem_free(pWdaParams);
8656 return ;
8657}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8658/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8659 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8660 * Free memory.
8661 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8662 */
8663void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8664{
8665 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8666
8667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8668 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8669
8670 if(NULL == pWdaParams)
8671 {
8672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8673 "%s: pWdaParams received NULL", __func__);
8674 VOS_ASSERT(0);
8675 return;
8676 }
8677
8678 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8679 {
8680 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8681 vos_mem_free(pWdaParams->wdaMsgParam);
8682 vos_mem_free(pWdaParams);
8683 }
8684
8685 return;
8686}
8687/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8688 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
8689 *
8690 */
8691VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
8692 tSirWlanSetRxpFilters *pWlanSuspendParam)
8693{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8694 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8695 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8696 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8697 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8698 /* Sanity Check
8699 * This is very unlikely and add assert to collect more info next time */
8700 if(NULL == pWlanSuspendParam)
8701 {
8702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8703 "%s: pWlanSuspendParam received NULL", __func__);
8704 VOS_ASSERT(0) ;
8705 return VOS_STATUS_E_FAULT;
8706 }
8707 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
8708 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8710 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8711 if(NULL == wdiRxpFilterParams)
8712 {
8713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8714 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8715 VOS_ASSERT(0);
8716 vos_mem_free(pWlanSuspendParam);
8717 return VOS_STATUS_E_NOMEM;
8718 }
8719 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8720 if(NULL == pWdaParams)
8721 {
8722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8723 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8724 VOS_ASSERT(0);
8725 vos_mem_free(wdiRxpFilterParams);
8726 vos_mem_free(pWlanSuspendParam);
8727 return VOS_STATUS_E_NOMEM;
8728 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8729 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
8730 pWlanSuspendParam->setMcstBcstFilter;
8731 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
8732 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8733
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8734 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
8735 wdiRxpFilterParams->pUserData = pWdaParams;
8736
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8737 pWdaParams->pWdaContext = pWDA;
8738 pWdaParams->wdaMsgParam = pWlanSuspendParam;
8739 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8740 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8741 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8742 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8743 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8744 {
8745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8746 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8747 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8748 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8749 vos_mem_free(pWdaParams->wdaMsgParam);
8750 vos_mem_free(pWdaParams);
8751 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8752 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8753}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8754/*
8755 * FUNCTION: WDA_WdiIndicationCallback
8756 *
8757 */
8758void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
8759 void* pUserData)
8760{
8761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8762 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8763}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8764/*
8765 * FUNCTION: WDA_ProcessWlanSuspendInd
8766 *
8767 */
8768VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
8769 tSirWlanSuspendParam *pWlanSuspendParam)
8770{
8771 WDI_Status wdiStatus;
8772 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8774 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8775 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
8776 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8777 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
8778 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "%s: %d" ,__func__, pWlanSuspendParam->configuredMcstBcstFilterSetting);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8780 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
8781 if(WDI_STATUS_PENDING == wdiStatus)
8782 {
8783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8784 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8785 }
8786 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8787 {
8788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8789 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8790 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8791 vos_mem_free(pWlanSuspendParam);
8792 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8793}
8794
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]8795#ifdef WLAN_FEATURE_11W
8796/*
8797 * FUNCTION: WDA_ProcessExcludeUnecryptInd
8798 *
8799 */
8800VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
8801 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
8802{
8803 WDI_Status wdiStatus;
8804 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
8805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8806 "------> %s ", __func__);
8807
8808 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
8809 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
8810 sizeof(tSirMacAddr));
8811
8812 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
8813 wdiExclUnencryptParams.pUserData = pWDA;
8814
8815 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
8816 if(WDI_STATUS_PENDING == wdiStatus)
8817 {
8818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8819 "Pending received for %s:%d ", __func__, __LINE__ );
8820 }
8821 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8822 {
8823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8824 "Failure in %s:%d ", __func__, __LINE__ );
8825 }
8826 vos_mem_free(pExclUnencryptParam);
8827 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8828}
8829#endif
8830
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8831/*
8832 * FUNCTION: WDA_ProcessWlanResumeCallback
8833 *
8834 */
8835void WDA_ProcessWlanResumeCallback(
8836 WDI_SuspendResumeRspParamsType *resumeRspParams,
8837 void* pUserData)
8838{
8839 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8841 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8842 if(NULL == pWdaParams)
8843 {
8844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8845 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8846 VOS_ASSERT(0) ;
8847 return ;
8848 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8849 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
8850 {
8851 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8852 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8854 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8855 vos_mem_free(pWdaParams->wdaMsgParam);
8856 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8857 return ;
8858}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8859/*
8860 * FUNCTION: WDA_ProcessWlanResumeReq
8861 *
8862 */
8863VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
8864 tSirWlanResumeParam *pWlanResumeParam)
8865{
8866 WDI_Status wdiStatus;
8867 WDI_ResumeParamsType *wdiResumeParams =
8868 (WDI_ResumeParamsType *)vos_mem_malloc(
8869 sizeof(WDI_ResumeParamsType) ) ;
8870 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8872 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8873 if(NULL == wdiResumeParams)
8874 {
8875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8876 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8877 VOS_ASSERT(0);
8878 return VOS_STATUS_E_NOMEM;
8879 }
8880 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8881 if(NULL == pWdaParams)
8882 {
8883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8884 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8885 VOS_ASSERT(0);
8886 vos_mem_free(wdiResumeParams);
8887 return VOS_STATUS_E_NOMEM;
8888 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8889 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
8890 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "%s: %d" ,__func__, pWlanResumeParam->configuredMcstBcstFilterSetting);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8892 wdiResumeParams->wdiReqStatusCB = NULL;
8893 pWdaParams->wdaMsgParam = pWlanResumeParam;
8894 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
8895 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8896 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
8897 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
8898 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8899 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8900 {
8901 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8902 "Failure in Host Resume REQ WDI API, free all the memory " );
8903 VOS_ASSERT(0);
8904 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8905 vos_mem_free(pWdaParams->wdaMsgParam);
8906 vos_mem_free(pWdaParams);
8907 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8908 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8909}
8910
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8911/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8912 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8913 *
8914 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8915void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8916{
8917 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8918 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8919 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8920 if(NULL == pWdaParams)
8921 {
8922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8923 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8924 VOS_ASSERT(0) ;
8925 return ;
8926 }
8927
8928 vos_mem_free(pWdaParams->wdaMsgParam) ;
8929 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8930 vos_mem_free(pWdaParams) ;
8931 /*
8932 * No respone required for SetBeaconFilter req so just free the request
8933 * param here
8934 */
8935
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8936 return ;
8937}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8938/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8939 * FUNCTION: WDA_SetBeaconFilterReqCallback
8940 * Free memory.
8941 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
8942 */
8943void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8944{
8945 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8946
8947 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8948 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8949
8950 if(NULL == pWdaParams)
8951 {
8952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8953 "%s: pWdaParams received NULL", __func__);
8954 VOS_ASSERT(0);
8955 return;
8956 }
8957
8958 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8959 {
8960 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8961 vos_mem_free(pWdaParams->wdaMsgParam);
8962 vos_mem_free(pWdaParams);
8963 }
8964
8965 return;
8966}
8967/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8968 * FUNCTION: WDA_SetBeaconFilterReq
8969 * Request to WDI to send the beacon filtering related information.
8970 */
8971VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
8972 tBeaconFilterMsg* pBeaconFilterInfo)
8973{
8974 WDI_Status status = WDI_STATUS_SUCCESS;
8975 tANI_U8 *dstPtr, *srcPtr;
8976 tANI_U8 filterLength;
8977 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
8978 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
8979 sizeof(WDI_BeaconFilterReqParamsType) ) ;
8980 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8982 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8983 if(NULL == wdiBeaconFilterInfo)
8984 {
8985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8986 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8987 VOS_ASSERT(0);
8988 return VOS_STATUS_E_NOMEM;
8989 }
8990 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8991 if(NULL == pWdaParams)
8992 {
8993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8994 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8995 VOS_ASSERT(0);
8996 vos_mem_free(wdiBeaconFilterInfo);
8997 return VOS_STATUS_E_NOMEM;
8998 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8999 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9000 pBeaconFilterInfo->beaconInterval;
9001 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9002 pBeaconFilterInfo->capabilityInfo;
9003 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9004 pBeaconFilterInfo->capabilityMask;
9005 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9006
9007 //Fill the BssIdx
9008 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9009
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9010 //Fill structure with info contained in the beaconFilterTable
9011 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9012 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9013 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9014 if(WDI_BEACON_FILTER_LEN < filterLength)
9015 {
9016 filterLength = WDI_BEACON_FILTER_LEN;
9017 }
9018 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9019 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9020 wdiBeaconFilterInfo->pUserData = pWdaParams;
9021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9022 /* Store param pointer as passed in by caller */
9023 /* store Params pass it to WDI */
9024 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9025 pWdaParams->pWdaContext = pWDA;
9026 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9027
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9028 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9029 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9030 if(IS_WDI_STATUS_FAILURE(status))
9031 {
9032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9033 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9034 vos_mem_free(pWdaParams->wdaMsgParam) ;
9035 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9036 vos_mem_free(pWdaParams) ;
9037 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9038 return CONVERT_WDI2VOS_STATUS(status) ;
9039}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9040/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9041 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9042 *
9043 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9044void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9045{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9046 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9047
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9049 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9050
9051 if(NULL == pWdaParams)
9052 {
9053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9054 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9055 VOS_ASSERT(0) ;
9056 return ;
9057 }
9058
9059 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9060 vos_mem_free(pWdaParams->wdaMsgParam);
9061 vos_mem_free(pWdaParams);
9062
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9063 //print a msg, nothing else to do
9064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9065 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9066 return ;
9067}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9068/*
9069 * FUNCTION: WDA_RemBeaconFilterReqCallback
9070 * Free memory.
9071 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9072 */
9073void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9074{
9075 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9076
9077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9078 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9079
9080 if(NULL == pWdaParams)
9081 {
9082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9083 "%s: pWdaParams received NULL", __func__);
9084 VOS_ASSERT(0);
9085 return;
9086 }
9087
9088 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9089 {
9090 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9091 vos_mem_free(pWdaParams->wdaMsgParam);
9092 vos_mem_free(pWdaParams);
9093 }
9094
9095 return;
9096}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9097 // TODO: PE does not have this feature for now implemented,
9098 // but the support for removing beacon filter exists between
9099 // HAL and FW. This function can be called whenever PE defines
9100 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9101/*
9102 * FUNCTION: WDA_RemBeaconFilterReq
9103 * Request to WDI to send the removal of beacon filtering related information.
9104 */
9105VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9106 tRemBeaconFilterMsg* pBeaconFilterInfo)
9107{
9108 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9109 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9110 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9111 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9112 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9113 tWDA_ReqParams *pWdaParams ;
9114
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9116 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9117 if(NULL == wdiBeaconFilterInfo)
9118 {
9119 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9120 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9121 VOS_ASSERT(0);
9122 return VOS_STATUS_E_NOMEM;
9123 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9124 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9125 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9126 {
9127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9128 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9129 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9130 vos_mem_free(wdiBeaconFilterInfo);
9131 vos_mem_free(pBeaconFilterInfo);
9132 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9133 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9134
9135 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9136 pBeaconFilterInfo->ucIeCount;
9137 //Fill structure with info contained in the ucRemIeId
9138 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9139 pBeaconFilterInfo->ucRemIeId,
9140 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9141 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9142 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9143
9144 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9145 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9146 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9147 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9148
9149 pWdaParams->pWdaContext = pWDA;
9150
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9151 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9152 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9153 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9154 {
9155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9156 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9157 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9158 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9159 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9160 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9161 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9162 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9163}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9164/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9165 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9166 *
9167 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9168void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9169{
9170 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9172 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9173 if(NULL == pWdaParams)
9174 {
9175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9176 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9177 VOS_ASSERT(0) ;
9178 return ;
9179 }
9180
9181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9182 vos_mem_free(pWdaParams) ;
9183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9184 return ;
9185}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9186/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9187 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9188 * Free memory.
9189 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9190 */
9191void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9192{
9193 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9194
9195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9196 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9197
9198 if(NULL == pWdaParams)
9199 {
9200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9201 "%s: pWdaParams received NULL", __func__);
9202 VOS_ASSERT(0);
9203 return;
9204 }
9205
9206 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9207 {
9208 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9209 vos_mem_free(pWdaParams);
9210 }
9211
9212 return;
9213}
9214/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9215 * FUNCTION: WDA_SetRSSIThresholdsReq
9216 * Request to WDI to set the RSSI thresholds (sta mode).
9217 */
9218VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9219{
9220 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9221 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9222 tWDA_CbContext *pWDA = NULL ;
9223 v_PVOID_t pVosContext = NULL;
9224 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9225 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9226 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9227 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9229 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9230 if(NULL == wdiRSSIThresholdsInfo)
9231 {
9232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9233 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9234 VOS_ASSERT(0);
9235 return VOS_STATUS_E_NOMEM;
9236 }
9237 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9238 if(NULL == pWdaParams)
9239 {
9240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9241 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9242 VOS_ASSERT(0);
9243 vos_mem_free(wdiRSSIThresholdsInfo);
9244 return VOS_STATUS_E_NOMEM;
9245 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9246 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9247 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9248 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9249 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9250 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9251 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9252 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9253 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9254 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9255 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9256 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9257 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9258 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9259 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9260
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9261 /* Store param pointer as passed in by caller */
9262 /* store Params pass it to WDI */
9263 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9264 pWdaParams->pWdaContext = pWDA;
9265 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9266 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9267 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9268 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9269 {
9270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9271 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9272 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9273 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9274 vos_mem_free(pWdaParams) ;
9275 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9276 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9277
9278}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9279/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9280 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9281 *
9282 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9283void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9284{
9285 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9286
9287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9288 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9289 if(NULL == pWdaParams)
9290 {
9291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9292 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9293 VOS_ASSERT(0) ;
9294 return ;
9295 }
9296
9297 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9298 vos_mem_free(pWdaParams->wdaMsgParam);
9299 vos_mem_free(pWdaParams) ;
9300
9301 //print a msg, nothing else to do
9302 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9303 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9304 return ;
9305}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9306/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9307 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9308 * Free memory.
9309 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9310 */
9311void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9312{
9313 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9314
9315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9316 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9317
9318 if(NULL == pWdaParams)
9319 {
9320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9321 "%s: Invalid pWdaParams pointer", __func__);
9322 VOS_ASSERT(0);
9323 return;
9324 }
9325
9326 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9327 {
9328 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9329 vos_mem_free(pWdaParams->wdaMsgParam);
9330 vos_mem_free(pWdaParams);
9331 }
9332
9333 return;
9334}
9335/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9336 * FUNCTION: WDA_ProcessHostOffloadReq
9337 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9338 * to broadcast traffic (sta mode).
9339 */
9340VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9341 tSirHostOffloadReq *pHostOffloadParams)
9342{
9343 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9344 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9345 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9346 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9347 sizeof(WDI_HostOffloadReqParamsType)) ;
9348 tWDA_ReqParams *pWdaParams ;
9349
9350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9351 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9352
9353 if(NULL == wdiHostOffloadInfo)
9354 {
9355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9356 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9357 VOS_ASSERT(0);
9358 return VOS_STATUS_E_NOMEM;
9359 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9360 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9361 if(NULL == pWdaParams)
9362 {
9363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9364 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9365 VOS_ASSERT(0);
9366 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9367 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9368 return VOS_STATUS_E_NOMEM;
9369 }
9370
9371 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9372 pHostOffloadParams->offloadType;
9373 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9374 pHostOffloadParams->enableOrDisable;
9375
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9376 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9377 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9378
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9379 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9380 {
9381 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9382 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9383 pHostOffloadParams->params.hostIpv4Addr,
9384 4);
9385 break;
9386 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9387 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9388 pHostOffloadParams->params.hostIpv6Addr,
9389 16);
9390 break;
9391 case SIR_IPV6_NS_OFFLOAD:
9392 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9393 pHostOffloadParams->params.hostIpv6Addr,
9394 16);
9395
9396#ifdef WLAN_NS_OFFLOAD
9397 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9398 {
9399 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9400 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9401 16);
9402 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9403 }
9404 else
9405 {
9406 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9407 }
9408
9409 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9410 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9411 16);
9412 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9413 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9414 6);
9415
9416 //Only two are supported so let's go through them without a loop
9417 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9418 {
9419 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9420 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9421 16);
9422 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9423 }
9424 else
9425 {
9426 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9427 }
9428
9429 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9430 {
9431 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9432 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9433 16);
9434 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9435 }
9436 else
9437 {
9438 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9439 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9440 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9441 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9442 break;
9443#endif //WLAN_NS_OFFLOAD
9444 default:
9445 {
9446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9447 "No Handling for Offload Type %x in WDA "
9448 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9449 //WDA_VOS_ASSERT(0) ;
9450 }
9451 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9452 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9453 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9454
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9455 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9456 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9457 /* store Params pass it to WDI */
9458 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9459 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9460
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9461
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9462 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9463 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9464
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9465 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9466 {
9467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9468 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9469 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9470 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9471 vos_mem_free(pWdaParams->wdaMsgParam);
9472 vos_mem_free(pWdaParams) ;
9473 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9474 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9475
9476}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9477/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9478 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9479 *
9480 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9481void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9482{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9483 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9484
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9486 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9487
9488 if(NULL == pWdaParams)
9489 {
9490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9491 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9492 VOS_ASSERT(0) ;
9493 return ;
9494 }
9495
9496 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9497 vos_mem_free(pWdaParams->wdaMsgParam);
9498 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9499
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9500 //print a msg, nothing else to do
9501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9502 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9503 return ;
9504}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9505/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9506 * FUNCTION: WDA_KeepAliveReqCallback
9507 * Free memory.
9508 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9509 */
9510void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9511{
9512 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9513
9514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9515 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9516
9517 if(NULL == pWdaParams)
9518 {
9519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9520 "%s: pWdaParams received NULL", __func__);
9521 VOS_ASSERT(0);
9522 return;
9523 }
9524
9525 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9526 {
9527 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9528 vos_mem_free(pWdaParams->wdaMsgParam);
9529 vos_mem_free(pWdaParams);
9530 }
9531
9532 return;
9533}
9534/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9535 * FUNCTION: WDA_ProcessKeepAliveReq
9536 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9537 * wakeup due to broadcast traffic (sta mode).
9538 */
9539VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9540 tSirKeepAliveReq *pKeepAliveParams)
9541{
9542 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9543 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9544 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9545 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9546 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9547 tWDA_ReqParams *pWdaParams;
9548
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9550 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9551 if(NULL == wdiKeepAliveInfo)
9552 {
9553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9554 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9556 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9557 return VOS_STATUS_E_NOMEM;
9558 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9559
9560 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9561 if(NULL == pWdaParams)
9562 {
9563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9564 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9565 VOS_ASSERT(0);
9566 vos_mem_free(wdiKeepAliveInfo);
9567 vos_mem_free(pKeepAliveParams);
9568 return VOS_STATUS_E_NOMEM;
9569 }
9570
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9571 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9572 pKeepAliveParams->packetType;
9573 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9574 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9575
9576 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9577 pKeepAliveParams->bssId,
9578 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9579
9580 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9581 {
9582 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9583 pKeepAliveParams->hostIpv4Addr,
9584 SIR_IPV4_ADDR_LEN);
9585 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9586 pKeepAliveParams->destIpv4Addr,
9587 SIR_IPV4_ADDR_LEN);
9588 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9589 pKeepAliveParams->destMacAddr,
9590 SIR_MAC_ADDR_LEN);
9591 }
9592 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9593 {
9594 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9595 SIR_IPV4_ADDR_LEN,
9596 0);
9597 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9598 SIR_IPV4_ADDR_LEN,
9599 0);
9600 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9601 SIR_MAC_ADDR_LEN,
9602 0);
9603 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9604 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9605 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9606
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9607 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9608 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9609 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9610 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9611 pWdaParams->pWdaContext = pWDA;
9612
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9614 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9615 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9616 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9617 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9619 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9620 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9621 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9622 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9624 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9625 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9626 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9627 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9628 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9629 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9630 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9632 "TimePeriod %d PacketType %d",
9633 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9634 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9635 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9636 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9637
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9638 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9639 {
9640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9641 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9642 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9643 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9644 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9645 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9646 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9647 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9648
9649}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9650/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9651 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9652 *
9653 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9654void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9655 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9656 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9657{
9658 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9660 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9661 if(NULL == pWdaParams)
9662 {
9663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9664 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9665 VOS_ASSERT(0) ;
9666 return ;
9667 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9668 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9669 vos_mem_free(pWdaParams->wdaMsgParam);
9670 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9671 return ;
9672}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9673/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9674 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
9675 * Free memory.
9676 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
9677 */
9678void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9679{
9680 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9681
9682 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9683 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9684
9685 if(NULL == pWdaParams)
9686 {
9687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9688 "%s: pWdaParams received NULL", __func__);
9689 VOS_ASSERT(0);
9690 return;
9691 }
9692
9693 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9694 {
9695 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9696 vos_mem_free(pWdaParams->wdaMsgParam);
9697 vos_mem_free(pWdaParams);
9698 }
9699
9700 return;
9701}
9702
9703/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9704 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
9705 * Request to WDI to add WOWL Bcast pattern
9706 */
9707VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
9708 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
9709{
9710 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9711 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9712 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
9713 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
9714 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
9715 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9717 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9718 if(NULL == wdiWowlAddBcPtrnInfo)
9719 {
9720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9721 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9722 VOS_ASSERT(0);
9723 return VOS_STATUS_E_NOMEM;
9724 }
9725 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9726 if(NULL == pWdaParams)
9727 {
9728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9729 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9730 VOS_ASSERT(0);
9731 vos_mem_free(wdiWowlAddBcPtrnInfo);
9732 return VOS_STATUS_E_NOMEM;
9733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9734 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
9735 pWowlAddBcPtrnParams->ucPatternId;
9736 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
9737 pWowlAddBcPtrnParams->ucPatternByteOffset;
9738 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
9739 pWowlAddBcPtrnParams->ucPatternMaskSize;
9740 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
9741 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9742 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
9743 {
9744 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9745 pWowlAddBcPtrnParams->ucPattern,
9746 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
9747 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9748 pWowlAddBcPtrnParams->ucPatternMask,
9749 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
9750 }
9751 else
9752 {
9753 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9754 pWowlAddBcPtrnParams->ucPattern,
9755 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9756 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9757 pWowlAddBcPtrnParams->ucPatternMask,
9758 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9759
9760 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
9761 pWowlAddBcPtrnParams->ucPatternExt,
9762 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9763 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
9764 pWowlAddBcPtrnParams->ucPatternMaskExt,
9765 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9766 }
9767
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9768 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
9769 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
9770
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9771 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
9772 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9773 /* Store param pointer as passed in by caller */
9774 /* store Params pass it to WDI */
9775 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
9776 pWdaParams->pWdaContext = pWDA;
9777 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9778 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9779 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9780 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9781 {
9782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9783 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9784 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9785 vos_mem_free(pWdaParams->wdaMsgParam) ;
9786 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9787 vos_mem_free(pWdaParams) ;
9788 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9789 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9790
9791}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9792/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9793 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9794 *
9795 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9796void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9797 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
9798 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9799{
9800 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9802 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9803 if(NULL == pWdaParams)
9804 {
9805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9806 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9807 VOS_ASSERT(0) ;
9808 return ;
9809 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9810 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9811 vos_mem_free(pWdaParams->wdaMsgParam);
9812 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9813 return ;
9814}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9815/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9816 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
9817 * Free memory.
9818 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
9819 */
9820void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9821{
9822 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9823
9824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9825 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9826
9827 if(NULL == pWdaParams)
9828 {
9829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9830 "%s: pWdaParams received NULL", __func__);
9831 VOS_ASSERT(0);
9832 return;
9833 }
9834
9835 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9836 {
9837 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9838 vos_mem_free(pWdaParams->wdaMsgParam);
9839 vos_mem_free(pWdaParams);
9840 }
9841
9842 return;
9843}
9844/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9845 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
9846 * Request to WDI to delete WOWL Bcast pattern
9847 */
9848VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
9849 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
9850{
9851 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9852 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9853 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
9854 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
9855 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
9856 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9858 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9859 if(NULL == wdiWowlDelBcPtrnInfo)
9860 {
9861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9862 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9863 VOS_ASSERT(0);
9864 return VOS_STATUS_E_NOMEM;
9865 }
9866 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9867 if(NULL == pWdaParams)
9868 {
9869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9870 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9871 VOS_ASSERT(0);
9872 vos_mem_free(wdiWowlDelBcPtrnInfo);
9873 return VOS_STATUS_E_NOMEM;
9874 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9875 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
9876 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9877
9878 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
9879 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
9880
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9881 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
9882 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9883 /* Store param pointer as passed in by caller */
9884 /* store Params pass it to WDI */
9885 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
9886 pWdaParams->pWdaContext = pWDA;
9887 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9888 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9889 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9890 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9891 {
9892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9893 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9894 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9895 vos_mem_free(pWdaParams->wdaMsgParam) ;
9896 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9897 vos_mem_free(pWdaParams) ;
9898 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9899 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9900
9901}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9902/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9903 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9904 *
9905 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9906void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9907{
9908 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9909 tWDA_CbContext *pWDA;
9910 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9912 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9913 if(NULL == pWdaParams)
9914 {
9915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9916 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9917 VOS_ASSERT(0) ;
9918 return ;
9919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9920 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
9921 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
9922
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9923 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
9924
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9925 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9926 vos_mem_free(pWdaParams) ;
9927
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9928 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9929 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9930 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9931 return ;
9932}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9933/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9934 * FUNCTION: WDA_WowlEnterReqCallback
9935 * Free memory and send WOWL Enter RSP back to PE.
9936 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
9937 */
9938void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
9939{
9940 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9941 tWDA_CbContext *pWDA;
9942 tSirHalWowlEnterParams *pWowlEnterParams;
9943
9944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9945 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9946
9947 if(NULL == pWdaParams)
9948 {
9949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9950 "%s: pWdaParams received NULL", __func__);
9951 VOS_ASSERT(0);
9952 return;
9953 }
9954
9955 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
9956 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
9957 pWowlEnterParams->status = wdiStatus;
9958
9959 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9960 {
9961 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9962 vos_mem_free(pWdaParams);
9963 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
9964 }
9965
9966 return;
9967}
9968/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9969 * FUNCTION: WDA_ProcessWowlEnterReq
9970 * Request to WDI to enter WOWL
9971 */
9972VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
9973 tSirHalWowlEnterParams *pWowlEnterParams)
9974{
9975 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9976 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9977 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
9978 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
9979 sizeof(WDI_WowlEnterReqParamsType)) ;
9980 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9982 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9983 if(NULL == wdiWowlEnterInfo)
9984 {
9985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9986 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9987 VOS_ASSERT(0);
9988 return VOS_STATUS_E_NOMEM;
9989 }
9990 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9991 if(NULL == pWdaParams)
9992 {
9993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9994 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9995 VOS_ASSERT(0);
9996 vos_mem_free(wdiWowlEnterInfo);
9997 return VOS_STATUS_E_NOMEM;
9998 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]9999
10000 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10001
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10002 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10003 pWowlEnterParams->magicPtrn,
10004 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10005 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10006 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10007 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10008 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10009 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10010 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10011 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10012 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10013 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10014 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10015 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10016 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10017 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10018 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10019 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10020 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10021#ifdef WLAN_WAKEUP_EVENTS
10022 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10023 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10024
10025 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10026 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10027
10028 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10029 pWowlEnterParams->ucWowNetScanOffloadMatch;
10030
10031 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10032 pWowlEnterParams->ucWowGTKRekeyError;
10033
10034 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10035 pWowlEnterParams->ucWoWBSSConnLoss;
10036#endif // WLAN_WAKEUP_EVENTS
10037
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10038 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10039 pWowlEnterParams->bssIdx;
10040
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10041 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10042 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10043 /* Store param pointer as passed in by caller */
10044 /* store Params pass it to WDI */
10045 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10046 pWdaParams->pWdaContext = pWDA;
10047 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10048 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10049 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10050 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10051 {
10052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10053 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10054 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10055 vos_mem_free(pWdaParams->wdaMsgParam) ;
10056 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10057 vos_mem_free(pWdaParams) ;
10058 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10059 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10060
10061}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10062/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10063 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10064 *
10065 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10066void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10068 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10069 tWDA_CbContext *pWDA;
10070 tSirHalWowlExitParams *pWowlExitParams;
10071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10072 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10073 if(NULL == pWdaParams)
10074 {
10075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10076 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10077 VOS_ASSERT(0) ;
10078 return ;
10079 }
10080 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10081 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10082
10083 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10084 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10085
10086 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10087 vos_mem_free(pWdaParams) ;
10088
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10090 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10091 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10092 return ;
10093}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10094/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10095 * FUNCTION: WDA_WowlExitReqCallback
10096 * Free memory and send WOWL Exit RSP back to PE.
10097 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10098 */
10099void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10100{
10101 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10102 tWDA_CbContext *pWDA;
10103 tSirHalWowlExitParams *pWowlExitParams;
10104
10105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10106 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10107
10108 if(NULL == pWdaParams)
10109 {
10110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10111 "%s: pWdaParams received NULL", __func__);
10112 VOS_ASSERT(0);
10113 return;
10114 }
10115
10116 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10117 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10118 pWowlExitParams->status = wdiStatus;
10119
10120 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10121 {
10122 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10123 vos_mem_free(pWdaParams);
10124 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10125 }
10126
10127 return;
10128}
10129/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10130 * FUNCTION: WDA_ProcessWowlExitReq
10131 * Request to WDI to add WOWL Bcast pattern
10132 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10133VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10134 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10135{
10136 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10137 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10138 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10139 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10140 sizeof(WDI_WowlExitReqParamsType)) ;
10141 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10143 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10144 if(NULL == wdiWowlExitInfo)
10145 {
10146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10147 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10148 VOS_ASSERT(0);
10149 return VOS_STATUS_E_NOMEM;
10150 }
10151 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10152 if(NULL == pWdaParams)
10153 {
10154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10155 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10156 VOS_ASSERT(0);
10157 vos_mem_free(wdiWowlExitInfo);
10158 return VOS_STATUS_E_NOMEM;
10159 }
10160
10161 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10162 pWowlExitParams->bssIdx;
10163
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10164 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10165 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10166
10167 /* Store param pointer as passed in by caller */
10168 /* store Params pass it to WDI */
10169 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10170 pWdaParams->pWdaContext = pWDA;
10171 pWdaParams->wdaMsgParam = pWowlExitParams;
10172
10173 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10174 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10175
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10176 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10177 {
10178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10179 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10180 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10182 vos_mem_free(pWdaParams->wdaMsgParam);
10183 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10184 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10185 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10186}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10187/*
10188 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10189 * Request to WDI to determine whether a given station is capable of
10190 * using HW-based frame translation
10191 */
10192v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10193 tANI_U8 staIdx)
10194{
10195 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10196}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10197
10198/*
10199 * FUNCTION: WDA_IsSelfSTA
10200 * Request to WDI to determine whether a given STAID is self station
10201 * index.
10202 */
10203v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10204{
10205
10206 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10207
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10208 if (NULL != pWDA)
10209 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10210 else
10211 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10212}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10213/*
10214 * FUNCTION: WDA_NvDownloadReqCallback
10215 * send NV Download RSP back to PE
10216 */
10217void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10218 void* pUserData)
10219{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10220
10221 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10222 tWDA_CbContext *pWDA;
10223
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10225 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10226
10227 if(NULL == pWdaParams)
10228 {
10229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10230 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10231 VOS_ASSERT(0) ;
10232 return ;
10233 }
10234
10235 pWDA = pWdaParams->pWdaContext;
10236
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10237 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10238 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10239 vos_mem_free(pWdaParams);
10240
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10241 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10242 return ;
10243}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10244/*
10245 * FUNCTION: WDA_ProcessNvDownloadReq
10246 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10247 */
10248VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10249{
10250 /* Initialize the local Variables*/
10251 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10252 v_VOID_t *pNvBuffer=NULL;
10253 v_SIZE_t bufferSize = 0;
10254 WDI_Status status = WDI_STATUS_E_FAILURE;
10255 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10256 tWDA_ReqParams *pWdaParams ;
10257
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10259 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10260 if(NULL == pWDA)
10261 {
10262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10263 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10264 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10265 return VOS_STATUS_E_FAILURE;
10266 }
10267
10268 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10269 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10270
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10271 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10272 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10273 if(NULL == wdiNvDownloadReqParam)
10274 {
10275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10276 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10277 VOS_ASSERT(0);
10278 return VOS_STATUS_E_NOMEM;
10279 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10280 /* Copy Params to wdiNvDownloadReqParam*/
10281 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10282 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10283
10284 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10285 if(NULL == pWdaParams)
10286 {
10287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10288 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10289 VOS_ASSERT(0);
10290 vos_mem_free(wdiNvDownloadReqParam);
10291 return VOS_STATUS_E_NOMEM;
10292 }
10293
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10294 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10295 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10296 pWdaParams->wdaMsgParam = NULL;
10297 pWdaParams->pWdaContext = pWDA;
10298
10299
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10300 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10302 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10303 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10304
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10305 if(IS_WDI_STATUS_FAILURE(status))
10306 {
10307 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10308 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10309 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10310 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10311 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10312 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10313}
10314/*
10315 * FUNCTION: WDA_FlushAcReqCallback
10316 * send Flush AC RSP back to TL
10317 */
10318void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10319{
10320 vos_msg_t wdaMsg = {0} ;
10321 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10322 tFlushACReq *pFlushACReqParams;
10323 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10325 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10326 if(NULL == pWdaParams)
10327 {
10328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10329 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10330 VOS_ASSERT(0) ;
10331 return ;
10332 }
10333
10334 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10335 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10336 if(NULL == pFlushACRspParams)
10337 {
10338 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10339 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10340 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10341 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10342 return ;
10343 }
10344 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10345 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10346 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10347 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10348 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10349 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10350 vos_mem_free(pWdaParams->wdaMsgParam) ;
10351 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10352 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10353 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10354 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10355 // POST message to TL
10356 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10357
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10358 return ;
10359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10360/*
10361 * FUNCTION: WDA_ProcessFlushAcReq
10362 * Request to WDI to Update the DELBA REQ params.
10363 */
10364VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10365 tFlushACReq *pFlushAcReqParams)
10366{
10367 WDI_Status status = WDI_STATUS_SUCCESS ;
10368 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10369 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10370 sizeof(WDI_FlushAcReqParamsType)) ;
10371 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10372 if(NULL == wdiFlushAcReqParam)
10373 {
10374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10375 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10376 VOS_ASSERT(0);
10377 return VOS_STATUS_E_NOMEM;
10378 }
10379 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10380 if(NULL == pWdaParams)
10381 {
10382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10383 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10384 VOS_ASSERT(0);
10385 vos_mem_free(wdiFlushAcReqParam);
10386 return VOS_STATUS_E_NOMEM;
10387 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10389 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10390 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10391 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10392 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10393 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10394 /* Store Flush AC pointer, as this will be used for response */
10395 /* store Params pass it to WDI */
10396 pWdaParams->pWdaContext = pWDA;
10397 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10398 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10399 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10400 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10401 if(IS_WDI_STATUS_FAILURE(status))
10402 {
10403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10404 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10405 vos_mem_free(pWdaParams->wdaMsgParam) ;
10406 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10407 vos_mem_free(pWdaParams) ;
10408 //TODO: respond to TL with failure
10409 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10410 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10411}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10412/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10413 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10414 *
10415 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10416void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10417{
10418 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10419 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10420 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10421
10422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10423 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10424 if(NULL == pWdaParams)
10425 {
10426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10427 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10428 VOS_ASSERT(0) ;
10429 return ;
10430 }
10431 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10432 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10433 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10434 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10435 {
10436 pWDA->wdaAmpSessionOn = VOS_FALSE;
10437 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10438 vos_mem_free(pWdaParams->wdaMsgParam) ;
10439 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10440 vos_mem_free(pWdaParams) ;
10441 /*
10442 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10443 * param here
10444 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10445 return ;
10446}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10447/*
10448 * FUNCTION: WDA_BtAmpEventReqCallback
10449 * Free memory.
10450 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10451 */
10452void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10453{
10454 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10455 tWDA_CbContext *pWDA;
10456 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10457
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10459 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10460
10461 if(NULL == pWdaParams)
10462 {
10463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10464 "%s: pWdaParams received NULL", __func__);
10465 VOS_ASSERT(0);
10466 return;
10467 }
10468
10469 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10470 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10471
10472 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10473 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10474 {
10475 pWDA->wdaAmpSessionOn = VOS_FALSE;
10476 }
10477
10478 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10479 {
10480 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10481 vos_mem_free(pWdaParams->wdaMsgParam);
10482 vos_mem_free(pWdaParams);
10483 }
10484
10485 return;
10486}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10487/*
10488 * FUNCTION: WDA_ProcessBtAmpEventReq
10489 * Request to WDI to Update with BT AMP events.
10490 */
10491VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10492 tSmeBtAmpEvent *pBtAmpEventParams)
10493{
10494 WDI_Status status = WDI_STATUS_SUCCESS ;
10495 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10496 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10497 sizeof(WDI_BtAmpEventParamsType)) ;
10498 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10500 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10501 if(NULL == wdiBtAmpEventParam)
10502 {
10503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10504 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10505 VOS_ASSERT(0);
10506 return VOS_STATUS_E_NOMEM;
10507 }
10508 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10509 if(NULL == pWdaParams)
10510 {
10511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10512 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10513 VOS_ASSERT(0);
10514 vos_mem_free(wdiBtAmpEventParam);
10515 return VOS_STATUS_E_NOMEM;
10516 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10517 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10518 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10519 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10520 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10521 /* Store BT AMP event pointer, as this will be used for response */
10522 /* store Params pass it to WDI */
10523 pWdaParams->pWdaContext = pWDA;
10524 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10525 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10526 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10527 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10528 if(IS_WDI_STATUS_FAILURE(status))
10529 {
10530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10531 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10532 vos_mem_free(pWdaParams->wdaMsgParam) ;
10533 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10534 vos_mem_free(pWdaParams) ;
10535 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10536 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10537 {
10538 pWDA->wdaAmpSessionOn = VOS_TRUE;
10539 }
10540 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10541}
10542
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10543/*
10544 * FUNCTION: WDA_FTMCommandReqCallback
10545 * Handle FTM CMD response came from HAL
10546 * Route responce to HDD FTM
10547 */
10548void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10549 void *usrData)
10550{
10551 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10552 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10553 {
10554 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10555 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10556 return;
10557 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10558 /* Release Current FTM Command Request */
10559 vos_mem_free(pWDA->wdaFTMCmdReq);
10560 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10561 /* Post FTM Responce to HDD FTM */
10562 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10563 return;
10564}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10565/*
10566 * FUNCTION: WDA_ProcessFTMCommand
10567 * Send FTM command to WDI
10568 */
10569VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10570 tPttMsgbuffer *pPTTFtmCmd)
10571{
10572 WDI_Status status = WDI_STATUS_SUCCESS;
10573 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10574 ftmCMDReq = (WDI_FTMCommandReqType *)
10575 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10576 if(NULL == ftmCMDReq)
10577 {
10578 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10579 "WDA FTM Command buffer alloc fail");
10580 return VOS_STATUS_E_NOMEM;
10581 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10582 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10583 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10584 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10585 /* Send command to WDI */
10586 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10587 return status;
10588}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10589#ifdef FEATURE_OEM_DATA_SUPPORT
10590/*
10591 * FUNCTION: WDA_StartOemDataReqCallback
10592 *
10593 */
10594void WDA_StartOemDataReqCallback(
10595 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10596 void* pUserData)
10597{
10598 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10599 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10600 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10601 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10602
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10604 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10605
10606 if(NULL == pWdaParams)
10607 {
10608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10609 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10610 VOS_ASSERT(0) ;
10611 return ;
10612 }
10613 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10614
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10615 if(NULL == pWDA)
10616 {
10617 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10618 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10619 VOS_ASSERT(0);
10620 return ;
10621 }
10622
10623 /*
10624 * Allocate memory for response params sent to PE
10625 */
10626 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10627
10628 // Check if memory is allocated for OemdataMeasRsp Params.
10629 if(NULL == pOemDataRspParams)
10630 {
10631 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10632 "OEM DATA WDA callback alloc fail");
10633 VOS_ASSERT(0) ;
10634 return;
10635 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10636
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10637 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10638 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10639 vos_mem_free(pWdaParams->wdaMsgParam);
10640 vos_mem_free(pWdaParams) ;
10641
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10642 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10643 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10644 * Also, here success always means that we have atleast one BSSID.
10645 */
10646 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10647
10648 //enable Tx
10649 status = WDA_ResumeDataTx(pWDA);
10650 if(status != VOS_STATUS_SUCCESS)
10651 {
10652 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10653 }
10654 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10655 return ;
10656}
10657/*
10658 * FUNCTION: WDA_ProcessStartOemDataReq
10659 * Send Start Oem Data Req to WDI
10660 */
10661VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10662 tStartOemDataReq *pOemDataReqParams)
10663{
10664 WDI_Status status = WDI_STATUS_SUCCESS;
10665 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10666 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10667
10668 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
10669
10670 if(NULL == wdiOemDataReqParams)
10671 {
10672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10673 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10674 VOS_ASSERT(0);
10675 return VOS_STATUS_E_NOMEM;
10676 }
10677
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10678 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
10679 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
10680 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
10681 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10682
10683 wdiOemDataReqParams->wdiReqStatusCB = NULL;
10684
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10685 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10686 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10687 {
10688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10689 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10690 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10691 vos_mem_free(pOemDataReqParams);
10692 VOS_ASSERT(0);
10693 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10694 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10695
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]10696 pWdaParams->pWdaContext = (void*)pWDA;
10697 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
10698 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10699
10700 status = WDI_StartOemDataReq(wdiOemDataReqParams,
10701 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10702
10703 if(IS_WDI_STATUS_FAILURE(status))
10704 {
10705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10706 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10707 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10708 vos_mem_free(pWdaParams->wdaMsgParam);
10709 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10710 }
10711 return CONVERT_WDI2VOS_STATUS(status) ;
10712}
10713#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10714/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10715 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10716 *
10717 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10718void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10719{
10720 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10721 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10722 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10723 if(NULL == pWdaParams)
10724 {
10725 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10726 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10727 VOS_ASSERT(0) ;
10728 return ;
10729 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10730
10731 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10732 vos_mem_free(pWdaParams->wdaMsgParam);
10733 vos_mem_free(pWdaParams);
10734
10735 return ;
10736}
10737/*
10738 * FUNCTION: WDA_SetTxPerTrackingReqCallback
10739 * Free memory.
10740 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
10741 */
10742void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
10743{
10744 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10745
10746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10747 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10748
10749 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10750 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10752 "%s: pWdaParams received NULL", __func__);
10753 VOS_ASSERT(0);
10754 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10755 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10756
10757 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10758 {
10759 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10760 vos_mem_free(pWdaParams->wdaMsgParam);
10761 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10762 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10763
10764 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10765}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10766#ifdef WLAN_FEATURE_GTK_OFFLOAD
10767/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10768 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10769 *
10770 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10771void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10772 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10773{
10774 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10775
10776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10777 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10778 if(NULL == pWdaParams)
10779 {
10780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10781 "%s: pWdaParams received NULL", __func__);
10782 VOS_ASSERT(0);
10783 return;
10784 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10785
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10786 vos_mem_free(pWdaParams->wdaMsgParam) ;
10787 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10788 vos_mem_free(pWdaParams) ;
10789
10790 //print a msg, nothing else to do
10791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10792 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10793
10794 return ;
10795}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10796/*
10797 * FUNCTION: WDA_GTKOffloadReqCallback
10798 * Free memory.
10799 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
10800 */
10801void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
10802{
10803 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10804
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10806 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10807
10808 if(NULL == pWdaParams)
10809 {
10810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10811 "%s: pWdaParams received NULL", __func__);
10812 VOS_ASSERT(0);
10813 return;
10814 }
10815
10816 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10817 {
10818 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10819 vos_mem_free(pWdaParams->wdaMsgParam);
10820 vos_mem_free(pWdaParams);
10821 }
10822
10823 return;
10824}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10825/*
10826 * FUNCTION: WDA_ProcessGTKOffloadReq
10827 * Request to WDI to set the filter to minimize unnecessary host wakeup due
10828 * to broadcast traffic (sta mode).
10829 */
10830VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
10831 tpSirGtkOffloadParams pGtkOffloadParams)
10832{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10833 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10834 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
10835 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
10836 sizeof(WDI_GtkOffloadReqMsg)) ;
10837 tWDA_ReqParams *pWdaParams ;
10838
10839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10840 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10841
10842 if(NULL == wdiGtkOffloadReqMsg)
10843 {
10844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10845 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10846 VOS_ASSERT(0);
10847 return VOS_STATUS_E_NOMEM;
10848 }
10849
10850 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10851 if(NULL == pWdaParams)
10852 {
10853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10854 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10855 VOS_ASSERT(0);
10856 vos_mem_free(wdiGtkOffloadReqMsg);
10857 return VOS_STATUS_E_NOMEM;
10858 }
10859
10860 //
10861 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
10862 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10863
10864 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10865 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10866
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10867 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
10868 // Copy KCK
10869 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
10870 // Copy KEK
10871 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
10872 // Copy KeyReplayCounter
10873 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
10874 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
10875
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10876 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
10877 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10878
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10879
10880 /* Store Params pass it to WDI */
10881 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
10882 pWdaParams->pWdaContext = pWDA;
10883 /* Store param pointer as passed in by caller */
10884 pWdaParams->wdaMsgParam = pGtkOffloadParams;
10885
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10886 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10887
10888 if(IS_WDI_STATUS_FAILURE(status))
10889 {
10890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10891 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
10892 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10893 vos_mem_free(pWdaParams->wdaMsgParam);
10894 vos_mem_free(pWdaParams);
10895 }
10896
10897 return CONVERT_WDI2VOS_STATUS(status) ;
10898}
10899
10900/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10901 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10902 *
10903 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10904void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10905 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10906{
10907 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10908 tWDA_CbContext *pWDA;
10909 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10910 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10911 vos_msg_t vosMsg;
10912
10913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10914 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10915
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10916 if(NULL == pWdaParams)
10917 {
10918 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10919 "%s: pWdaParams received NULL", __func__);
10920 VOS_ASSERT(0);
10921 return;
10922 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10923
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10924 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
10925 if(NULL == pGtkOffloadGetInfoRsp)
10926 {
10927 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10928 "%s: vos_mem_malloc failed ", __func__);
10929 VOS_ASSERT(0);
10930 return;
10931 }
10932
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10933 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10934 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
10935
10936 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
10937 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
10938
10939 /* Message Header */
10940 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]10941 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10942
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10943 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
10944 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
10945 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
10946 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
10947 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10948
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10949 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
10950 pwdiGtkOffloadGetInfoRsparams->bssId,
10951 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10952 /* VOS message wrapper */
10953 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
10954 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
10955 vosMsg.bodyval = 0;
10956
10957 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
10958 {
10959 /* free the mem and return */
10960 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
10961 }
10962
10963 vos_mem_free(pWdaParams->wdaMsgParam) ;
10964 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10965 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10966
10967 return;
10968}
10969/*
10970 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
10971 * Free memory and send RSP back to SME.
10972 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
10973 */
10974void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
10975{
10976 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10977 vos_msg_t vosMsg;
10978
10979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10980 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10981
10982 if(NULL == pWdaParams)
10983 {
10984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10985 "%s: pWdaParams received NULL", __func__);
10986 VOS_ASSERT(0);
10987 return;
10988 }
10989
10990 /* VOS message wrapper */
10991 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
10992 vosMsg.bodyptr = NULL;
10993 vosMsg.bodyval = 0;
10994
10995 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10996 {
10997 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10998 vos_mem_free(pWdaParams->wdaMsgParam);
10999 vos_mem_free(pWdaParams);
11000 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11001 }
11002
11003 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11004}
11005#endif
11006
11007/*
11008 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11009 * Request to WDI to set Tx Per Tracking configurations
11010 */
11011VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11012{
11013 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11014 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11015 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11016 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11017 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11018 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11020 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11021 if(NULL == pwdiSetTxPerTrackingReqParams)
11022 {
11023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11024 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11025 vos_mem_free(pTxPerTrackingParams);
11026 VOS_ASSERT(0);
11027 return VOS_STATUS_E_NOMEM;
11028 }
11029 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11030 if(NULL == pWdaParams)
11031 {
11032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11033 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11034 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11035 vos_mem_free(pTxPerTrackingParams);
11036 VOS_ASSERT(0);
11037 return VOS_STATUS_E_NOMEM;
11038 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11039 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11040 pTxPerTrackingParams->ucTxPerTrackingEnable;
11041 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11042 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11043 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11044 pTxPerTrackingParams->ucTxPerTrackingRatio;
11045 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11046 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11047 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11048 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11049 /* Store param pointer as passed in by caller */
11050 /* store Params pass it to WDI
11051 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11052 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11053 pWdaParams->pWdaContext = pWDA;
11054 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11055 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11056 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11057 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11058 {
11059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11060 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11061 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11062 vos_mem_free(pWdaParams->wdaMsgParam) ;
11063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11064 vos_mem_free(pWdaParams) ;
11065 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11066 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11067
11068}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11069/*
11070 * FUNCTION: WDA_HALDumpCmdCallback
11071 * Send the VOS complete .
11072 */
11073void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11074 void* pUserData)
11075{
11076 tANI_U8 *buffer = NULL;
11077 tWDA_CbContext *pWDA = NULL;
11078 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11079 if(NULL == pWdaParams)
11080 {
11081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11082 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11083 VOS_ASSERT(0) ;
11084 return ;
11085 }
11086
11087 pWDA = pWdaParams->pWdaContext;
11088 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11089 if(wdiRspParams->usBufferLen > 0)
11090 {
11091 /*Copy the Resp data to UMAC supplied buffer*/
11092 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11093 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11094 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11095 vos_mem_free(pWdaParams);
11096
11097 /* Indicate VOSS about the start complete */
11098 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11099 return ;
11100}
11101
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11102/*
11103 * FUNCTION: WDA_ProcessHALDumpCmdReq
11104 * Send Dump command to WDI
11105 */
11106VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11107 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11108 tANI_U32 arg4, tANI_U8 *pBuffer)
11109{
11110 WDI_Status status = WDI_STATUS_SUCCESS;
11111 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11112 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11113 tWDA_ReqParams *pWdaParams ;
11114 pVosContextType pVosContext = NULL;
11115 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11116 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11117 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11118 if(pVosContext)
11119 {
11120 if (pVosContext->isLogpInProgress)
11121 {
11122 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11123 "%s:LOGP in Progress. Ignore!!!", __func__);
11124 return VOS_STATUS_E_BUSY;
11125 }
11126 }
11127 else
11128 {
11129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11130 "%s: VOS Context Null", __func__);
11131 return VOS_STATUS_E_RESOURCES;
11132 }
11133
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11134 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11135 if(NULL == pWdaParams)
11136 {
11137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11138 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11139 return VOS_STATUS_E_NOMEM;
11140 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11141 /* Allocate memory WDI request structure*/
11142 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11143 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11144 if(NULL == wdiHALDumpCmdReqParam)
11145 {
11146 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11147 "WDA HAL DUMP Command buffer alloc fail");
11148 vos_mem_free(pWdaParams);
11149 return WDI_STATUS_E_FAILURE;
11150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11151 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11152 /* Extract the arguments */
11153 wdiHalDumpCmdInfo->command = cmd;
11154 wdiHalDumpCmdInfo->argument1 = arg1;
11155 wdiHalDumpCmdInfo->argument2 = arg2;
11156 wdiHalDumpCmdInfo->argument3 = arg3;
11157 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11158 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11159 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11160
11161 /* Response message will be passed through the buffer */
11162 pWdaParams->wdaMsgParam = (void *)pBuffer;
11163
11164 /* store Params pass it to WDI */
11165 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11166 /* Send command to WDI */
11167 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11168 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11169 if ( vStatus != VOS_STATUS_SUCCESS )
11170 {
11171 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11172 {
11173 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11174 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11175 }
11176 else
11177 {
11178 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11179 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11180 }
11181 VOS_ASSERT(0);
11182 }
11183 return status;
11184}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11185#ifdef WLAN_FEATURE_GTK_OFFLOAD
11186/*
11187 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11188 * Request to WDI to get GTK Offload Information
11189 */
11190VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11191 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11192{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11193 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11194 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11195 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11196 tWDA_ReqParams *pWdaParams ;
11197
11198 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11199 {
11200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11201 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11202 VOS_ASSERT(0);
11203 return VOS_STATUS_E_NOMEM;
11204 }
11205
11206 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11207 if(NULL == pWdaParams)
11208 {
11209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11210 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11211 VOS_ASSERT(0);
11212 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11213 return VOS_STATUS_E_NOMEM;
11214 }
11215
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11216 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11217 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11218
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11219 /* Store Params pass it to WDI */
11220 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11221 pWdaParams->pWdaContext = pWDA;
11222 /* Store param pointer as passed in by caller */
11223 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11224
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11225 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11226 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11227
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11228 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11229
11230 if(IS_WDI_STATUS_FAILURE(status))
11231 {
11232 /* failure returned by WDI API */
11233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11234 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11235 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11236 vos_mem_free(pWdaParams) ;
11237 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11238 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11239 }
11240
11241 return CONVERT_WDI2VOS_STATUS(status) ;
11242}
11243#endif // WLAN_FEATURE_GTK_OFFLOAD
11244
11245/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11246 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11247 *
11248 */
11249VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11250 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11251{
11252 WDI_Status wdiStatus;
11253 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11254
11255 addPeriodicTxPtrnParams =
11256 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11257
11258 if (NULL == addPeriodicTxPtrnParams)
11259 {
11260 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11261 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11262 __func__);
11263
11264 return VOS_STATUS_E_NOMEM;
11265 }
11266
11267 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11268 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11269
11270 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11271 addPeriodicTxPtrnParams->pUserData = pWDA;
11272
11273 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11274
11275 if (WDI_STATUS_PENDING == wdiStatus)
11276 {
11277 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11278 "Pending received for %s:%d", __func__, __LINE__ );
11279 }
11280 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11281 {
11282 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11283 "Failure in %s:%d", __func__, __LINE__ );
11284 }
11285
11286 vos_mem_free(addPeriodicTxPtrnParams);
11287
11288 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11289}
11290
11291/*
11292 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11293 *
11294 */
11295VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11296 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11297{
11298 WDI_Status wdiStatus;
11299 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11300
11301 delPeriodicTxPtrnParams =
11302 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11303
11304 if (NULL == delPeriodicTxPtrnParams)
11305 {
11306 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11307 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11308 __func__);
11309
11310 return VOS_STATUS_E_NOMEM;
11311 }
11312
11313 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11314 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11315
11316 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11317 delPeriodicTxPtrnParams->pUserData = pWDA;
11318
11319 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11320
11321 if (WDI_STATUS_PENDING == wdiStatus)
11322 {
11323 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11324 "Pending received for %s:%d", __func__, __LINE__ );
11325 }
11326 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11327 {
11328 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11329 "Failure in %s:%d", __func__, __LINE__ );
11330 }
11331
11332 vos_mem_free(delPeriodicTxPtrnParams);
11333
11334 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11335}
11336
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11337#ifdef FEATURE_WLAN_BATCH_SCAN
11338/*
11339 * FUNCTION: WDA_ProcessStopBatchScanInd
11340 *
11341 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11342 *
11343 * PARAM:
11344 * pWDA: pointer to WDA context
11345 * pReq: pointer to stop batch scan request
11346 */
11347VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11348 tSirStopBatchScanInd *pReq)
11349{
11350 WDI_Status wdiStatus;
11351 WDI_StopBatchScanIndType wdiReq;
11352
11353 wdiReq.param = pReq->param;
11354
11355 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11356
11357 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11358 {
11359 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11360 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11361 }
11362
11363 vos_mem_free(pReq);
11364
11365 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11366}
11367/*==========================================================================
11368 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11369
11370 DESCRIPTION
11371 API to pull batch scan result from FW
11372
11373 PARAMETERS
11374 pWDA: Pointer to WDA context
11375 pGetBatchScanReq: Pointer to get batch scan result indication
11376
11377 RETURN VALUE
11378 NONE
11379
11380===========================================================================*/
11381VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11382 tSirTriggerBatchScanResultInd *pReq)
11383{
11384 WDI_Status wdiStatus;
11385 WDI_TriggerBatchScanResultIndType wdiReq;
11386
11387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11388 "------> %s " ,__func__);
11389
11390 wdiReq.param = pReq->param;
11391
11392 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11393
11394 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11395 {
11396 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11397 "Trigger batch scan result ind failed %s:%d",
11398 __func__, wdiStatus);
11399 }
11400
11401 vos_mem_free(pReq);
11402
11403 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11404}
11405
11406/*==========================================================================
11407 FUNCTION WDA_SetBatchScanRespCallback
11408
11409 DESCRIPTION
11410 API to process set batch scan response from FW
11411
11412 PARAMETERS
11413 pRsp: Pointer to set batch scan response
11414 pUserData: Pointer to user data
11415
11416 RETURN VALUE
11417 NONE
11418
11419===========================================================================*/
11420void WDA_SetBatchScanRespCallback
11421(
11422 WDI_SetBatchScanRspType *pRsp,
11423 void* pUserData
11424)
11425{
11426 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11427 tpAniSirGlobal pMac;
11428 void *pCallbackContext;
11429 tWDA_CbContext *pWDA = NULL ;
11430 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11431
11432
11433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11434 "<------ %s " ,__func__);
11435 if (NULL == pWdaParams)
11436 {
11437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11438 "%s: pWdaParams received NULL", __func__);
11439 VOS_ASSERT(0) ;
11440 return ;
11441 }
11442
11443 /*extract WDA context*/
11444 pWDA = pWdaParams->pWdaContext;
11445 if (NULL == pWDA)
11446 {
11447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11448 "%s:pWDA is NULL can't invole HDD callback",
11449 __func__);
11450 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11451 vos_mem_free(pWdaParams->wdaMsgParam);
11452 vos_mem_free(pWdaParams);
11453 VOS_ASSERT(0);
11454 return;
11455 }
11456
11457 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11458 vos_mem_free(pWdaParams->wdaMsgParam);
11459 vos_mem_free(pWdaParams);
11460
11461 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11462 if (NULL == pMac)
11463 {
11464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11465 "%s:pMac is NULL", __func__);
11466 VOS_ASSERT(0);
11467 return;
11468 }
11469
11470 pHddSetBatchScanRsp =
11471 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11472 if (NULL == pHddSetBatchScanRsp)
11473 {
11474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11475 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11476 VOS_ASSERT(0);
11477 return;
11478 }
11479
11480 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11481
11482 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11483 /*call hdd callback with set batch scan response data*/
11484 if(pMac->pmc.setBatchScanReqCallback)
11485 {
11486 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11487 }
11488 else
11489 {
11490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11491 "%s:HDD callback is null", __func__);
11492 VOS_ASSERT(0);
11493 }
11494
11495 vos_mem_free(pHddSetBatchScanRsp);
11496 return ;
11497}
11498
11499/*==========================================================================
11500 FUNCTION WDA_ProcessSetBatchScanReq
11501
11502 DESCRIPTION
11503 API to send set batch scan request to WDI
11504
11505 PARAMETERS
11506 pWDA: Pointer to WDA context
11507 pSetBatchScanReq: Pointer to set batch scan req
11508
11509 RETURN VALUE
11510 NONE
11511
11512===========================================================================*/
11513VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11514 tSirSetBatchScanReq *pSetBatchScanReq)
11515{
11516 WDI_Status status;
11517 tWDA_ReqParams *pWdaParams ;
11518 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11519
11520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11521 "------> %s " ,__func__);
11522
11523 pWdiSetBatchScanReq =
11524 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11525 if (NULL == pWdiSetBatchScanReq)
11526 {
11527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11528 "%s: VOS MEM Alloc Failure", __func__);
11529 vos_mem_free(pSetBatchScanReq);
11530 VOS_ASSERT(0);
11531 return VOS_STATUS_E_NOMEM;
11532 }
11533
11534 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11535 if (NULL == pWdaParams)
11536 {
11537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11538 "%s: VOS MEM Alloc Failure", __func__);
11539 VOS_ASSERT(0);
11540 vos_mem_free(pSetBatchScanReq);
11541 vos_mem_free(pWdiSetBatchScanReq);
11542 return VOS_STATUS_E_NOMEM;
11543 }
11544
11545 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11546 pWdiSetBatchScanReq->numberOfScansToBatch =
11547 pSetBatchScanReq->numberOfScansToBatch;
11548 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11549 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11550 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11551
11552 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11553 pWdaParams->pWdaContext = pWDA;
11554 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11555
11556 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11557 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11558 if (IS_WDI_STATUS_FAILURE(status))
11559 {
11560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11561 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11562 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11563 vos_mem_free(pWdaParams->wdaMsgParam);
11564 vos_mem_free(pWdaParams);
11565 }
11566 return CONVERT_WDI2VOS_STATUS(status);
11567}
11568
11569#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11570/*
11571 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11572 *
11573 * DESCRIPTION: This function sends start/update OBSS scan
11574 * inidcation message to WDI
11575 *
11576 * PARAM:
11577 * pWDA: pointer to WDA context
11578 * pReq: pointer to start OBSS scan request
11579 */
11580VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11581 tSirHT40OBSSScanInd *pReq)
11582{
11583 WDI_Status status;
11584 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11585 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11586
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11588 "------> %s " ,__func__);
11589 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11590 wdiOBSSScanParams.pUserData = pWDA;
11591
11592 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11593 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11594 pWdiOBSSScanInd->scanType = pReq->scanType;
11595 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11596 pReq->OBSSScanActiveDwellTime;
11597 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11598 pReq->OBSSScanPassiveDwellTime;
11599 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11600 pReq->BSSChannelWidthTriggerScanInterval;
11601 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11602 pReq->BSSWidthChannelTransitionDelayFactor;
11603 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11604 pReq->OBSSScanActiveTotalPerChannel;
11605 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11606 pReq->OBSSScanPassiveTotalPerChannel;
11607 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11608 pReq->OBSSScanActivityThreshold;
11609 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11610 vos_mem_copy(pWdiOBSSScanInd->channels,
11611 pReq->channels,
11612 pReq->channelCount);
11613 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11614 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11615 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11616 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11617 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11618
11619 vos_mem_copy(pWdiOBSSScanInd->ieField,
11620 pReq->ieField,
11621 pReq->ieFieldLen);
11622
11623 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11624 if (WDI_STATUS_PENDING == status)
11625 {
11626 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11627 "Pending received for %s:%d ",__func__,__LINE__ );
11628 }
11629 else if (WDI_STATUS_SUCCESS_SYNC != status)
11630 {
11631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11632 "Failure in %s:%d ",__func__,__LINE__ );
11633 }
11634 return CONVERT_WDI2VOS_STATUS(status) ;
11635}
11636/*
11637 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11638 *
11639 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11640 *
11641 * PARAM:
11642 * pWDA: pointer to WDA context
11643 * pReq: pointer to stop batch scan request
11644 */
11645VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11646 tANI_U8 *bssIdx)
11647{
11648 WDI_Status status;
11649
11650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11651 "------> %s " ,__func__);
11652
11653 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11654 if (WDI_STATUS_PENDING == status)
11655 {
11656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11657 "Pending received for %s:%d ",__func__,__LINE__ );
11658 }
11659 else if (WDI_STATUS_SUCCESS_SYNC != status)
11660 {
11661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11662 "Failure in %s:%d ",__func__,__LINE__ );
11663 }
11664 return CONVERT_WDI2VOS_STATUS(status) ;
11665}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11666/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11667 * FUNCTION: WDA_ProcessRateUpdateInd
11668 *
11669 */
11670VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
11671 tSirRateUpdateInd *pRateUpdateParams)
11672{
11673 WDI_Status wdiStatus;
11674 WDI_RateUpdateIndParams rateUpdateParams;
11675
11676 vos_mem_copy(rateUpdateParams.bssid,
11677 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
11678
11679 rateUpdateParams.ucastDataRateTxFlag =
11680 pRateUpdateParams->ucastDataRateTxFlag;
11681 rateUpdateParams.reliableMcastDataRateTxFlag =
11682 pRateUpdateParams->reliableMcastDataRateTxFlag;
11683 rateUpdateParams.mcastDataRate24GHzTxFlag =
11684 pRateUpdateParams->mcastDataRate24GHzTxFlag;
11685 rateUpdateParams.mcastDataRate5GHzTxFlag =
11686 pRateUpdateParams->mcastDataRate5GHzTxFlag;
11687
11688 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
11689 rateUpdateParams.reliableMcastDataRate =
11690 pRateUpdateParams->reliableMcastDataRate;
11691 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
11692 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
11693
11694 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11695 rateUpdateParams.pUserData = pWDA;
11696
11697 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
11698
11699 if (WDI_STATUS_PENDING == wdiStatus)
11700 {
11701 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11702 "Pending received for %s:%d", __func__, __LINE__ );
11703 }
11704 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11705 {
11706 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11707 "Failure in %s:%d", __func__, __LINE__ );
11708 }
11709
11710 vos_mem_free(pRateUpdateParams);
11711
11712 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11713}
11714
11715/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11716 * -------------------------------------------------------------------------
11717 * DATA interface with WDI for Mgmt Frames
11718 * -------------------------------------------------------------------------
11719 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11720/*
11721 * FUNCTION: WDA_TxComplete
11722 * Callback function for the WDA_TxPacket
11723 */
11724VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
11725 VOS_STATUS status )
11726{
11727
11728 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
11729 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11730 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11731
11732 if(NULL == wdaContext)
11733 {
11734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11735 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11736 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11737 VOS_ASSERT(0);
11738 return VOS_STATUS_E_FAILURE;
11739 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11740
11741 /*Check if frame was timed out or not*/
11742 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
11743 (v_PVOID_t)&uUserData);
11744
11745 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
11746 {
11747 /*Discard frame - no further processing is needed*/
11748 vos_pkt_return_packet(pData);
11749 return VOS_STATUS_SUCCESS;
11750 }
11751
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11752 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
11753 if( NULL!=wdaContext->pTxCbFunc)
11754 {
11755 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11756 if(vos_atomic_set((uintptr_t*)&wdaContext->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED) == (uintptr_t)pData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11757 {
11758 wdaContext->pTxCbFunc(pMac, pData);
11759 }
11760 else
11761 {
11762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11763 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11764 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11765 //Return from here since we reaching here because the packet already timeout
11766 return status;
11767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11768 }
11769
11770 /*
11771 * Trigger the event to bring the HAL TL Tx complete function to come
11772 * out of wait
11773 * Let the coe above to complete the packet first. When this event is set,
11774 * the thread waiting for the event may run and set Vospacket_freed causing the original
11775 * packet not being freed.
11776 */
11777 status = vos_event_set(&wdaContext->txFrameEvent);
11778 if(!VOS_IS_STATUS_SUCCESS(status))
11779 {
11780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11781 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11783 return status;
11784}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11785/*
11786 * FUNCTION: WDA_TxPacket
11787 * Forward TX management frame to WDI
11788 */
11789VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
11790 void *pFrmBuf,
11791 tANI_U16 frmLen,
11792 eFrameType frmType,
11793 eFrameTxDir txDir,
11794 tANI_U8 tid,
11795 pWDATxRxCompFunc pCompFunc,
11796 void *pData,
11797 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]11798 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11799{
11800 VOS_STATUS status = VOS_STATUS_SUCCESS ;
11801 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
11802 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
11803 tANI_U8 eventIdx = 0;
11804 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
11805 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11806 if((NULL == pWDA)||(NULL == pFrmBuf))
11807 {
11808 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11809 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11810 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11811 VOS_ASSERT(0);
11812 return VOS_STATUS_E_FAILURE;
11813 }
11814
11815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11816 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11817 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11818 if(NULL == pMac)
11819 {
11820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11821 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11822 VOS_ASSERT(0);
11823 return VOS_STATUS_E_FAILURE;
11824 }
11825
11826
11827
11828 /* store the call back function in WDA context */
11829 pWDA->pTxCbFunc = pCompFunc;
11830 /* store the call back for the function of ackTxComplete */
11831 if( pAckTxComp )
11832 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11833 if( NULL != pWDA->pAckTxCbFunc )
11834 {
11835 /* Already TxComp is active no need to active again */
11836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11837 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11838 pWDA->pAckTxCbFunc( pMac, 0);
11839 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11840
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11841 if( VOS_STATUS_SUCCESS !=
11842 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11843 {
11844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11845 "Tx Complete timeout Timer Stop Failed ");
11846 }
11847 else
11848 {
11849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]11850 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11851 }
11852 }
11853
11854 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
11855 pWDA->pAckTxCbFunc = pAckTxComp;
11856 if( VOS_STATUS_SUCCESS !=
11857 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
11858 {
11859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11860 "Tx Complete Timer Start Failed ");
11861 pWDA->pAckTxCbFunc = NULL;
11862 return eHAL_STATUS_FAILURE;
11863 }
11864 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11865 /* Reset the event to be not signalled */
11866 status = vos_event_reset(&pWDA->txFrameEvent);
11867 if(!VOS_IS_STATUS_SUCCESS(status))
11868 {
11869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11870 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11871 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
11872 if( pAckTxComp )
11873 {
11874 pWDA->pAckTxCbFunc = NULL;
11875 if( VOS_STATUS_SUCCESS !=
11876 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11877 {
11878 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11879 "Tx Complete timeout Timer Stop Failed ");
11880 }
11881 }
11882 return VOS_STATUS_E_FAILURE;
11883 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11884
11885 /* If Peer Sta mask is set don't overwrite to self sta */
11886 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11887 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11888 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11889 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11890 else
11891 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11892 /* Get system role, use the self station if in unknown role or STA role */
11893 systemRole = wdaGetGlobalSystemRole(pMac);
11894 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
11895 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]11896#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11897 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11898#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11899 ))
11900 {
11901 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
11902 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]11903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11904
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11905 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
11906 disassoc frame reaches the HW, HAL has already deleted the peer station */
11907 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11908 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]11909 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11910 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11911 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11912 /*Send Probe request frames on self sta idx*/
11913 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11915 /* Since we donot want probe responses to be retried, send probe responses
11916 through the NO_ACK queues */
11917 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
11918 {
11919 //probe response is sent out using self station and no retries options.
11920 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
11921 }
11922 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
11923 {
11924 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
11925 }
11926 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11927 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)pFrmBuf);/*set VosPacket_freed to pFrmBuf*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11928
11929 /*Set frame tag to 0
11930 We will use the WDA user data in order to tag a frame as expired*/
11931 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
11932 (v_PVOID_t)0);
11933
11934
11935 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
11936 frmLen, ucTypeSubType, tid,
11937 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
11938 {
11939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11940 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11941 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11942 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (v_U32_t)WDA_TX_PACKET_FREED);/*reset the VosPacket_freed*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11943 if( pAckTxComp )
11944 {
11945 pWDA->pAckTxCbFunc = NULL;
11946 if( VOS_STATUS_SUCCESS !=
11947 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11948 {
11949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11950 "Tx Complete timeout Timer Stop Failed ");
11951 }
11952 }
11953 return VOS_STATUS_E_FAILURE;
11954 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11955 /*
11956 * Wait for the event to be set by the TL, to get the response of TX
11957 * complete, this event should be set by the Callback function called by TL
11958 */
11959 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
11960 &eventIdx);
11961 if(!VOS_IS_STATUS_SUCCESS(status))
11962 {
11963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11964 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11965 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11966 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
11967 after the packet gets completed(packet freed once)*/
11968
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]11969 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]11970 WDA_TransportChannelDebug(pMac, 1, WPAL_DEBUG_TX_DESC_RESYNC);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]11971
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11972 /*Tag Frame as timed out for later deletion*/
11973 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
11974 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
11975
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11976 /* check whether the packet was freed already,so need not free again when
11977 * TL calls the WDA_Txcomplete routine
11978 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11979 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
11980 /*if(vos_atomic_set(uintptr_t *)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED) == (v_U32_t)pFrmBuf)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11981 {
11982 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11983 } */
11984
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11985 if( pAckTxComp )
11986 {
11987 pWDA->pAckTxCbFunc = NULL;
11988 if( VOS_STATUS_SUCCESS !=
11989 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11990 {
11991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11992 "Tx Complete timeout Timer Stop Failed ");
11993 }
11994 }
11995 status = VOS_STATUS_E_FAILURE;
11996 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]11997#ifdef WLAN_DUMP_MGMTFRAMES
11998 if (VOS_IS_STATUS_SUCCESS(status))
11999 {
12000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12001 "%s() TX packet : SubType %d", __func__,pFc->subType);
12002 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12003 pData, frmLen);
12004 }
12005#endif
12006
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12007 if (VOS_IS_STATUS_SUCCESS(status))
12008 {
12009 if (pMac->fEnableDebugLog & 0x1)
12010 {
12011 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12012 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12013 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12014 {
12015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12016 pFc->type, pFc->subType);
12017 }
12018 }
12019 }
12020
12021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12022 return status;
12023}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12024/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12025 * FUNCTION: WDA_ProcessDHCPStartInd
12026 * Forward DHCP Start to WDI
12027 */
12028static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12029 tAniDHCPInd *dhcpStartInd)
12030{
12031 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12032 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12033
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12034 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12035 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12036 sizeof(tSirMacAddr));
12037
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12038 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12039
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12040 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12041 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12043 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12044 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12045 else if (WDI_STATUS_SUCCESS_SYNC != status)
12046 {
12047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12048 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12049 }
12050
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12051 vos_mem_free(dhcpStartInd);
12052 return CONVERT_WDI2VOS_STATUS(status) ;
12053}
12054
12055 /*
12056 * FUNCTION: WDA_ProcessDHCPStopInd
12057 * Forward DHCP Stop to WDI
12058 */
12059 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12060 tAniDHCPInd *dhcpStopInd)
12061 {
12062 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12063 WDI_DHCPInd wdiDHCPInd;
12064
12065 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12066 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12067
12068 status = WDI_dhcpStopInd(&wdiDHCPInd);
12069
12070 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12071 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12073 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12074 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12075 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12076 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12078 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12079 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12080
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12081 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12082
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12083 return CONVERT_WDI2VOS_STATUS(status) ;
12084 }
12085
12086/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12087 * FUNCTION: WDA_McProcessMsg
12088 * Trigger DAL-AL to start CFG download
12089 */
12090VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12091{
12092 VOS_STATUS status = VOS_STATUS_SUCCESS;
12093 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12094 if(NULL == pMsg)
12095 {
12096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12097 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12098 VOS_ASSERT(0);
12099 return VOS_STATUS_E_FAILURE;
12100 }
12101
12102 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12103 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12104
12105 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12106 if(NULL == pWDA )
12107 {
12108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12109 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12110 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12111 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12112 return VOS_STATUS_E_FAILURE;
12113 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12114 /* Process all the WDA messages.. */
12115 switch( pMsg->type )
12116 {
12117 case WNI_CFG_DNLD_REQ:
12118 {
12119 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12120 /* call WDA complete event if config download success */
12121 if( VOS_IS_STATUS_SUCCESS(status) )
12122 {
12123 vos_WDAComplete_cback(pVosContext);
12124 }
12125 else
12126 {
12127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12128 "WDA Config Download failure" );
12129 }
12130 break ;
12131 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12132 /*
12133 * Init SCAN request from PE, convert it into DAL format
12134 * and send it to DAL
12135 */
12136 case WDA_INIT_SCAN_REQ:
12137 {
12138 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12139 break ;
12140 }
12141 /* start SCAN request from PE */
12142 case WDA_START_SCAN_REQ:
12143 {
12144 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12145 break ;
12146 }
12147 /* end SCAN request from PE */
12148 case WDA_END_SCAN_REQ:
12149 {
12150 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12151 break ;
12152 }
12153 /* end SCAN request from PE */
12154 case WDA_FINISH_SCAN_REQ:
12155 {
12156 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12157 break ;
12158 }
12159 /* join request from PE */
12160 case WDA_CHNL_SWITCH_REQ:
12161 {
12162 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12163 {
12164 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12165 }
12166 else
12167 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12168 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12169 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12170 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12171 {
12172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12173 "call ProcessChannelSwitchReq_V1" );
12174 WDA_ProcessChannelSwitchReq_V1(pWDA,
12175 (tSwitchChannelParams*)pMsg->bodyptr) ;
12176 }
12177 else
12178 {
12179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12180 "call ProcessChannelSwitchReq" );
12181 WDA_ProcessChannelSwitchReq(pWDA,
12182 (tSwitchChannelParams*)pMsg->bodyptr) ;
12183 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12184 }
12185 break ;
12186 }
12187 /* ADD BSS request from PE */
12188 case WDA_ADD_BSS_REQ:
12189 {
12190 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12191 break ;
12192 }
12193 case WDA_ADD_STA_REQ:
12194 {
12195 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12196 break ;
12197 }
12198 case WDA_DELETE_BSS_REQ:
12199 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12200 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12201 break ;
12202 }
12203 case WDA_DELETE_STA_REQ:
12204 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12205 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12206 break ;
12207 }
12208 case WDA_CONFIG_PARAM_UPDATE_REQ:
12209 {
12210 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12211 break ;
12212 }
12213 case WDA_SET_BSSKEY_REQ:
12214 {
12215 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12216 break ;
12217 }
12218 case WDA_SET_STAKEY_REQ:
12219 {
12220 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12221 break ;
12222 }
12223 case WDA_SET_STA_BCASTKEY_REQ:
12224 {
12225 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12226 break ;
12227 }
12228 case WDA_REMOVE_BSSKEY_REQ:
12229 {
12230 WDA_ProcessRemoveBssKeyReq(pWDA,
12231 (tRemoveBssKeyParams *)pMsg->bodyptr);
12232 break ;
12233 }
12234 case WDA_REMOVE_STAKEY_REQ:
12235 {
12236 WDA_ProcessRemoveStaKeyReq(pWDA,
12237 (tRemoveStaKeyParams *)pMsg->bodyptr);
12238 break ;
12239 }
12240 case WDA_REMOVE_STA_BCASTKEY_REQ:
12241 {
12242 /* TODO: currently UMAC is not sending this request, Add the code for
12243 handling this request when UMAC supports */
12244 break;
12245 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12246#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12247 case WDA_TSM_STATS_REQ:
12248 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12249 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12250 break;
12251 }
12252#endif
12253 case WDA_UPDATE_EDCA_PROFILE_IND:
12254 {
12255 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12256 break;
12257 }
12258 case WDA_ADD_TS_REQ:
12259 {
12260 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12261 break;
12262 }
12263 case WDA_DEL_TS_REQ:
12264 {
12265 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12266 break;
12267 }
12268 case WDA_ADDBA_REQ:
12269 {
12270 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12271 break;
12272 }
12273 case WDA_DELBA_IND:
12274 {
12275 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12276 break;
12277 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12278 case WDA_UPDATE_CHAN_LIST_REQ:
12279 {
12280 WDA_ProcessUpdateChannelList(pWDA,
12281 (tSirUpdateChanList *)pMsg->bodyptr);
12282 break;
12283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12284 case WDA_SET_LINK_STATE:
12285 {
12286 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12287 break;
12288 }
12289 case WDA_GET_STATISTICS_REQ:
12290 {
12291 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12292 break;
12293 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12294#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12295 case WDA_GET_ROAM_RSSI_REQ:
12296 {
12297 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12298 break;
12299 }
12300#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12301 case WDA_PWR_SAVE_CFG:
12302 {
12303 if(pWDA->wdaState == WDA_READY_STATE)
12304 {
12305 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12306 }
12307 else
12308 {
12309 if(NULL != pMsg->bodyptr)
12310 {
12311 vos_mem_free(pMsg->bodyptr);
12312 }
12313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12314 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12315 }
12316 break;
12317 }
12318 case WDA_ENTER_IMPS_REQ:
12319 {
12320 if(pWDA->wdaState == WDA_READY_STATE)
12321 {
12322 WDA_ProcessEnterImpsReq(pWDA);
12323 }
12324 else
12325 {
12326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12327 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12328 }
12329 break;
12330 }
12331 case WDA_EXIT_IMPS_REQ:
12332 {
12333 if(pWDA->wdaState == WDA_READY_STATE)
12334 {
12335 WDA_ProcessExitImpsReq(pWDA);
12336 }
12337 else
12338 {
12339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12340 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12341 }
12342 break;
12343 }
12344 case WDA_ENTER_BMPS_REQ:
12345 {
12346 if(pWDA->wdaState == WDA_READY_STATE)
12347 {
12348 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12349 }
12350 else
12351 {
12352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12353 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12354 }
12355 break;
12356 }
12357 case WDA_EXIT_BMPS_REQ:
12358 {
12359 if(pWDA->wdaState == WDA_READY_STATE)
12360 {
12361 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12362 }
12363 else
12364 {
12365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12366 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12367 }
12368 break;
12369 }
12370 case WDA_ENTER_UAPSD_REQ:
12371 {
12372 if(pWDA->wdaState == WDA_READY_STATE)
12373 {
12374 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12375 }
12376 else
12377 {
12378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12379 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12380 }
12381 break;
12382 }
12383 case WDA_EXIT_UAPSD_REQ:
12384 {
12385 if(pWDA->wdaState == WDA_READY_STATE)
12386 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12387 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12388 }
12389 else
12390 {
12391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12392 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12393 }
12394 break;
12395 }
12396 case WDA_UPDATE_UAPSD_IND:
12397 {
12398 if(pWDA->wdaState == WDA_READY_STATE)
12399 {
12400 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12401 }
12402 else
12403 {
12404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12405 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12406 }
12407 break;
12408 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12409 case WDA_REGISTER_PE_CALLBACK :
12410 {
12411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12412 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12413 /*TODO: store the PE callback */
12414 /* Do Nothing? MSG Body should be freed at here */
12415 if(NULL != pMsg->bodyptr)
12416 {
12417 vos_mem_free(pMsg->bodyptr);
12418 }
12419 break;
12420 }
12421 case WDA_SYS_READY_IND :
12422 {
12423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12424 "Handling msg type WDA_SYS_READY_IND " );
12425 pWDA->wdaState = WDA_READY_STATE;
12426 if(NULL != pMsg->bodyptr)
12427 {
12428 vos_mem_free(pMsg->bodyptr);
12429 }
12430 break;
12431 }
12432 case WDA_BEACON_FILTER_IND :
12433 {
12434 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12435 break;
12436 }
12437 case WDA_BTC_SET_CFG:
12438 {
12439 /*TODO: handle this while dealing with BTC */
12440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12441 "Handling msg type WDA_BTC_SET_CFG " );
12442 /* Do Nothing? MSG Body should be freed at here */
12443 if(NULL != pMsg->bodyptr)
12444 {
12445 vos_mem_free(pMsg->bodyptr);
12446 }
12447 break;
12448 }
12449 case WDA_SIGNAL_BT_EVENT:
12450 {
12451 /*TODO: handle this while dealing with BTC */
12452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12453 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12454 /* Do Nothing? MSG Body should be freed at here */
12455 if(NULL != pMsg->bodyptr)
12456 {
12457 vos_mem_free(pMsg->bodyptr);
12458 }
12459 break;
12460 }
12461 case WDA_CFG_RXP_FILTER_REQ:
12462 {
12463 WDA_ProcessConfigureRxpFilterReq(pWDA,
12464 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12465 break;
12466 }
12467 case WDA_SET_HOST_OFFLOAD:
12468 {
12469 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12470 break;
12471 }
12472 case WDA_SET_KEEP_ALIVE:
12473 {
12474 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12475 break;
12476 }
12477#ifdef WLAN_NS_OFFLOAD
12478 case WDA_SET_NS_OFFLOAD:
12479 {
12480 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12481 break;
12482 }
12483#endif //WLAN_NS_OFFLOAD
12484 case WDA_ADD_STA_SELF_REQ:
12485 {
12486 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12487 break;
12488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12489 case WDA_DEL_STA_SELF_REQ:
12490 {
12491 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12492 break;
12493 }
12494 case WDA_WOWL_ADD_BCAST_PTRN:
12495 {
12496 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12497 break;
12498 }
12499 case WDA_WOWL_DEL_BCAST_PTRN:
12500 {
12501 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12502 break;
12503 }
12504 case WDA_WOWL_ENTER_REQ:
12505 {
12506 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12507 break;
12508 }
12509 case WDA_WOWL_EXIT_REQ:
12510 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12511 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12512 break;
12513 }
12514 case WDA_TL_FLUSH_AC_REQ:
12515 {
12516 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12517 break;
12518 }
12519 case WDA_SIGNAL_BTAMP_EVENT:
12520 {
12521 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12522 break;
12523 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12524#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12525 case WDA_LINK_LAYER_STATS_SET_REQ:
12526 {
12527 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12528 break;
12529 }
12530 case WDA_LINK_LAYER_STATS_GET_REQ:
12531 {
12532 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12533 break;
12534 }
12535 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12536 {
12537 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12538 break;
12539 }
12540#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12541#ifdef WLAN_FEATURE_EXTSCAN
12542 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12543 {
12544 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12545 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12546 break;
12547 }
12548 case WDA_EXTSCAN_START_REQ:
12549 {
12550 WDA_ProcessEXTScanStartReq(pWDA,
12551 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12552 break;
12553 }
12554 case WDA_EXTSCAN_STOP_REQ:
12555 {
12556 WDA_ProcessEXTScanStopReq(pWDA,
12557 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12558 break;
12559 }
12560 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12561 {
12562 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12563 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12564 break;
12565 }
12566 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12567 {
12568 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12569 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12570 break;
12571 }
12572 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12573 {
12574 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12575 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12576 break;
12577 }
12578 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12579 {
12580 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12581 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12582 break;
12583 }
12584 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12585 {
12586 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12587 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12588 break;
12589 }
12590#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12591#ifdef WDA_UT
12592 case WDA_WDI_EVENT_MSG:
12593 {
12594 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12595 break ;
12596 }
12597#endif
12598 case WDA_UPDATE_BEACON_IND:
12599 {
12600 WDA_ProcessUpdateBeaconParams(pWDA,
12601 (tUpdateBeaconParams *)pMsg->bodyptr);
12602 break;
12603 }
12604 case WDA_SEND_BEACON_REQ:
12605 {
12606 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12607 break;
12608 }
12609 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12610 {
12611 WDA_ProcessUpdateProbeRspTemplate(pWDA,
12612 (tSendProbeRespParams *)pMsg->bodyptr);
12613 break;
12614 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12615#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12616 case WDA_SET_MAX_TX_POWER_REQ:
12617 {
12618 WDA_ProcessSetMaxTxPowerReq(pWDA,
12619 (tMaxTxPowerParams *)pMsg->bodyptr);
12620 break;
12621 }
12622#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]12623 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
12624 {
12625 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
12626 pMsg->bodyptr);
12627 break;
12628 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]12629 case WDA_SET_TX_POWER_REQ:
12630 {
12631 WDA_ProcessSetTxPowerReq(pWDA,
12632 (tSirSetTxPowerReq *)pMsg->bodyptr);
12633 break;
12634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12635 case WDA_SET_P2P_GO_NOA_REQ:
12636 {
12637 WDA_ProcessSetP2PGONOAReq(pWDA,
12638 (tP2pPsParams *)pMsg->bodyptr);
12639 break;
12640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12641 /* timer related messages */
12642 case WDA_TIMER_BA_ACTIVITY_REQ:
12643 {
12644 WDA_BaCheckActivity(pWDA) ;
12645 break ;
12646 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]12647
12648 /* timer related messages */
12649 case WDA_TIMER_TRAFFIC_STATS_IND:
12650 {
12651 WDA_TimerTrafficStatsInd(pWDA);
12652 break;
12653 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12654#ifdef WLAN_FEATURE_VOWIFI_11R
12655 case WDA_AGGR_QOS_REQ:
12656 {
12657 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
12658 break;
12659 }
12660#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12661 case WDA_FTM_CMD_REQ:
12662 {
12663 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
12664 break ;
12665 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12666#ifdef FEATURE_OEM_DATA_SUPPORT
12667 case WDA_START_OEM_DATA_REQ:
12668 {
12669 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
12670 break;
12671 }
12672#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12673 /* Tx Complete Time out Indication */
12674 case WDA_TX_COMPLETE_TIMEOUT_IND:
12675 {
12676 WDA_ProcessTxCompleteTimeOutInd(pWDA);
12677 break;
12678 }
12679 case WDA_WLAN_SUSPEND_IND:
12680 {
12681 WDA_ProcessWlanSuspendInd(pWDA,
12682 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
12683 break;
12684 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12685 case WDA_WLAN_RESUME_REQ:
12686 {
12687 WDA_ProcessWlanResumeReq(pWDA,
12688 (tSirWlanResumeParam *)pMsg->bodyptr) ;
12689 break;
12690 }
12691
12692 case WDA_UPDATE_CF_IND:
12693 {
12694 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
12695 pMsg->bodyptr = NULL;
12696 break;
12697 }
12698#ifdef FEATURE_WLAN_SCAN_PNO
12699 case WDA_SET_PNO_REQ:
12700 {
12701 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
12702 break;
12703 }
12704 case WDA_UPDATE_SCAN_PARAMS_REQ:
12705 {
12706 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
12707 break;
12708 }
12709 case WDA_SET_RSSI_FILTER_REQ:
12710 {
12711 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
12712 break;
12713 }
12714#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12715#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12716 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12717 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12718 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12719 break;
12720 }
12721#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12722 case WDA_SET_TX_PER_TRACKING_REQ:
12723 {
12724 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
12725 break;
12726 }
12727
12728#ifdef WLAN_FEATURE_PACKET_FILTERING
12729 case WDA_8023_MULTICAST_LIST_REQ:
12730 {
12731 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
12732 break;
12733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12734 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
12735 {
12736 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
12737 break;
12738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12739 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
12740 {
12741 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
12742 break;
12743 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12744 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
12745 {
12746 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
12747 break;
12748 }
12749#endif // WLAN_FEATURE_PACKET_FILTERING
12750
12751
12752 case WDA_TRANSMISSION_CONTROL_IND:
12753 {
12754 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
12755 break;
12756 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12757 case WDA_SET_POWER_PARAMS_REQ:
12758 {
12759 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
12760 break;
12761 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12762#ifdef WLAN_FEATURE_GTK_OFFLOAD
12763 case WDA_GTK_OFFLOAD_REQ:
12764 {
12765 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
12766 break;
12767 }
12768
12769 case WDA_GTK_OFFLOAD_GETINFO_REQ:
12770 {
12771 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
12772 break;
12773 }
12774#endif //WLAN_FEATURE_GTK_OFFLOAD
12775
12776 case WDA_SET_TM_LEVEL_REQ:
12777 {
12778 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
12779 break;
12780 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12781
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12782 case WDA_UPDATE_OP_MODE:
12783 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12784 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
12785 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
12786 {
12787 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12788 }
12789 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12790 {
12791 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
12792 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12793 else
12794 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12795 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12796 }
12797 else
12798 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12799 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12800 break;
12801 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]12802#ifdef WLAN_FEATURE_11W
12803 case WDA_EXCLUDE_UNENCRYPTED_IND:
12804 {
12805 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
12806 break;
12807 }
12808#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]12809#ifdef FEATURE_WLAN_TDLS
12810 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
12811 {
12812 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
12813 break;
12814 }
12815#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12816 case WDA_DHCP_START_IND:
12817 {
12818 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12819 break;
12820 }
12821 case WDA_DHCP_STOP_IND:
12822 {
12823 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12824 break;
12825 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]12826#ifdef FEATURE_WLAN_LPHB
12827 case WDA_LPHB_CONF_REQ:
12828 {
12829 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
12830 break;
12831 }
12832#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]12833 case WDA_ADD_PERIODIC_TX_PTRN_IND:
12834 {
12835 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
12836 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
12837 break;
12838 }
12839 case WDA_DEL_PERIODIC_TX_PTRN_IND:
12840 {
12841 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
12842 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
12843 break;
12844 }
12845
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12846#ifdef FEATURE_WLAN_BATCH_SCAN
12847 case WDA_SET_BATCH_SCAN_REQ:
12848 {
12849 WDA_ProcessSetBatchScanReq(pWDA,
12850 (tSirSetBatchScanReq *)pMsg->bodyptr);
12851 break;
12852 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]12853 case WDA_RATE_UPDATE_IND:
12854 {
12855 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
12856 break;
12857 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12858 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
12859 {
12860 WDA_ProcessTriggerBatchScanResultInd(pWDA,
12861 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
12862 break;
12863 }
12864 case WDA_STOP_BATCH_SCAN_IND:
12865 {
12866 WDA_ProcessStopBatchScanInd(pWDA,
12867 (tSirStopBatchScanInd *)pMsg->bodyptr);
12868 break;
12869 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]12870 case WDA_GET_BCN_MISS_RATE_REQ:
12871 WDA_ProcessGetBcnMissRateReq(pWDA,
12872 (tSirBcnMissRateReq *)pMsg->bodyptr);
12873 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12874#endif
12875
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]12876 case WDA_HT40_OBSS_SCAN_IND:
12877 {
12878 WDA_ProcessHT40OBSSScanInd(pWDA,
12879 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
12880 break;
12881 }
12882 case WDA_HT40_OBSS_STOP_SCAN_IND:
12883 {
12884 WDA_ProcessHT40OBSSStopScanInd(pWDA,
12885 (tANI_U8*)pMsg->bodyptr);
12886 break;
12887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12888 default:
12889 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]12890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12891 "No Handling for msg type %x in WDA "
12892 ,pMsg->type);
12893 /* Do Nothing? MSG Body should be freed at here */
12894 if(NULL != pMsg->bodyptr)
12895 {
12896 vos_mem_free(pMsg->bodyptr);
12897 }
12898 //WDA_VOS_ASSERT(0) ;
12899 }
12900 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12901 return status ;
12902}
12903
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12904/*
12905 * FUNCTION: WDA_LowLevelIndCallback
12906 * IND API callback from WDI, send Ind to PE
12907 */
12908void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
12909 void* pUserData )
12910{
12911 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
12912#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12913 tSirRSSINotification rssiNotification;
12914#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12915 if(NULL == pWDA)
12916 {
12917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12918 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12919 VOS_ASSERT(0);
12920 return ;
12921 }
12922
12923 switch(wdiLowLevelInd->wdiIndicationType)
12924 {
12925 case WDI_RSSI_NOTIFICATION_IND:
12926 {
12927 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12928 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12929#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12930 rssiNotification.bReserved =
12931 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
12932 rssiNotification.bRssiThres1NegCross =
12933 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
12934 rssiNotification.bRssiThres1PosCross =
12935 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
12936 rssiNotification.bRssiThres2NegCross =
12937 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
12938 rssiNotification.bRssiThres2PosCross =
12939 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
12940 rssiNotification.bRssiThres3NegCross =
12941 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
12942 rssiNotification.bRssiThres3PosCross =
12943 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]12944 rssiNotification.avgRssi = (v_S7_t)
12945 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12946 WLANTL_BMPSRSSIRegionChangedNotification(
12947 pWDA->pVosContext,
12948 &rssiNotification);
12949#endif
12950 break ;
12951 }
12952 case WDI_MISSED_BEACON_IND:
12953 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]12954 tpSirSmeMissedBeaconInd pMissBeacInd =
12955 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12957 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12958 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]12959 if(NULL == pMissBeacInd)
12960 {
12961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12962 "%s: VOS MEM Alloc Failure", __func__);
12963 break;
12964 }
12965 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
12966 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
12967 pMissBeacInd->bssIdx =
12968 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
12969 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12970 break ;
12971 }
12972 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
12973 {
12974 /* TODO: Decode Ind and send Ind to PE */
12975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12976 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
12977 break ;
12978 }
12979
12980 case WDI_MIC_FAILURE_IND:
12981 {
12982 tpSirSmeMicFailureInd pMicInd =
12983 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
12984
12985 if(NULL == pMicInd)
12986 {
12987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12988 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12989 break;
12990 }
12991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12992 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12993 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
12994 pMicInd->length = sizeof(tSirSmeMicFailureInd);
12995 vos_mem_copy(pMicInd->bssId,
12996 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
12997 sizeof(tSirMacAddr));
12998 vos_mem_copy(pMicInd->info.srcMacAddr,
12999 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13000 sizeof(tSirMacAddr));
13001 vos_mem_copy(pMicInd->info.taMacAddr,
13002 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13003 sizeof(tSirMacAddr));
13004 vos_mem_copy(pMicInd->info.dstMacAddr,
13005 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13006 sizeof(tSirMacAddr));
13007 vos_mem_copy(pMicInd->info.rxMacAddr,
13008 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13009 sizeof(tSirMacAddr));
13010 pMicInd->info.multicast =
13011 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13012 pMicInd->info.keyId=
13013 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13014 pMicInd->info.IV1=
13015 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13016 vos_mem_copy(pMicInd->info.TSC,
13017 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13018 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13019 (void *)pMicInd , 0) ;
13020 break ;
13021 }
13022 case WDI_FATAL_ERROR_IND:
13023 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13024 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13025 /* TODO: Decode Ind and send Ind to PE */
13026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13027 "Received WDI_FATAL_ERROR_IND from WDI ");
13028 break ;
13029 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13030 case WDI_DEL_STA_IND:
13031 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13032 tpDeleteStaContext pDelSTACtx =
13033 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13034
13035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13036 "Received WDI_DEL_STA_IND from WDI ");
13037 if(NULL == pDelSTACtx)
13038 {
13039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13040 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13041 break;
13042 }
13043 vos_mem_copy(pDelSTACtx->addr2,
13044 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13045 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13046 vos_mem_copy(pDelSTACtx->bssId,
13047 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13048 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13049 pDelSTACtx->assocId =
13050 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13051 pDelSTACtx->reasonCode =
13052 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13053 pDelSTACtx->staId =
13054 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13055 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13056 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13057 break ;
13058 }
13059 case WDI_COEX_IND:
13060 {
13061 tANI_U32 index;
13062 vos_msg_t vosMsg;
13063 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13064 if(NULL == pSmeCoexInd)
13065 {
13066 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13067 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13068 break;
13069 }
13070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13071 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13072 /* Message Header */
13073 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13074 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13075 /* Info from WDI Indication */
13076 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13077 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13078 {
13079 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13080 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13081 /* VOS message wrapper */
13082 vosMsg.type = eWNI_SME_COEX_IND;
13083 vosMsg.bodyptr = (void *)pSmeCoexInd;
13084 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13085 /* Send message to SME */
13086 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13087 {
13088 /* free the mem and return */
13089 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13090 }
13091 else
13092 {
13093 /* DEBUG */
13094 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13095 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13096 pSmeCoexInd->coexIndType,
13097 pSmeCoexInd->coexIndData[0],
13098 pSmeCoexInd->coexIndData[1],
13099 pSmeCoexInd->coexIndData[2],
13100 pSmeCoexInd->coexIndData[3]);
13101 }
13102 break;
13103 }
13104 case WDI_TX_COMPLETE_IND:
13105 {
13106 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13107 /* Calling TxCompleteAck Indication from wda context*/
13108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13109 "Complete Indication received from HAL");
13110 if( pWDA->pAckTxCbFunc )
13111 {
13112 if( VOS_STATUS_SUCCESS !=
13113 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13114 {
13115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13116 "Tx Complete timeout Timer Stop Failed ");
13117 }
13118 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13119 pWDA->pAckTxCbFunc = NULL;
13120 }
13121 else
13122 {
13123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13124 "Tx Complete Indication is received after timeout ");
13125 }
13126 break;
13127 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13128 case WDI_P2P_NOA_START_IND :
13129 {
13130 tSirP2PNoaStart *pP2pNoaStart =
13131 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13132
13133 if (NULL == pP2pNoaStart)
13134 {
13135 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13136 "Memory allocation failure, "
13137 "WDI_P2P_NOA_START_IND not forwarded");
13138 break;
13139 }
13140 pP2pNoaStart->status =
13141 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13142 pP2pNoaStart->bssIdx =
13143 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13144 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13145 (void *)pP2pNoaStart , 0) ;
13146 break;
13147 }
13148
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13149#ifdef FEATURE_WLAN_TDLS
13150 case WDI_TDLS_IND :
13151 {
13152 tSirTdlsInd *pTdlsInd =
13153 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13154
13155 if (NULL == pTdlsInd)
13156 {
13157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13158 "Memory allocation failure, "
13159 "WDI_TDLS_IND not forwarded");
13160 break;
13161 }
13162 pTdlsInd->status =
13163 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13164 pTdlsInd->assocId =
13165 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13166 pTdlsInd->staIdx =
13167 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13168 pTdlsInd->reasonCode =
13169 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13170 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13171 (void *)pTdlsInd , 0) ;
13172 break;
13173 }
13174#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13175 case WDI_P2P_NOA_ATTR_IND :
13176 {
13177 tSirP2PNoaAttr *pP2pNoaAttr =
13178 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13180 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13181 if (NULL == pP2pNoaAttr)
13182 {
13183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13184 "Memory allocation failure, "
13185 "WDI_P2P_NOA_ATTR_IND not forwarded");
13186 break;
13187 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13188 pP2pNoaAttr->index =
13189 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13190 pP2pNoaAttr->oppPsFlag =
13191 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13192 pP2pNoaAttr->ctWin =
13193 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13194
13195 pP2pNoaAttr->uNoa1IntervalCnt =
13196 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13197 pP2pNoaAttr->uNoa1Duration =
13198 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13199 pP2pNoaAttr->uNoa1Interval =
13200 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13201 pP2pNoaAttr->uNoa1StartTime =
13202 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13203 pP2pNoaAttr->uNoa2IntervalCnt =
13204 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13205 pP2pNoaAttr->uNoa2Duration =
13206 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13207 pP2pNoaAttr->uNoa2Interval =
13208 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13209 pP2pNoaAttr->uNoa2StartTime =
13210 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13211 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13212 (void *)pP2pNoaAttr , 0) ;
13213 break;
13214 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13215#ifdef FEATURE_WLAN_SCAN_PNO
13216 case WDI_PREF_NETWORK_FOUND_IND:
13217 {
13218 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13219 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13220 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13221 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13222 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13223
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13225 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13226 if (NULL == pPrefNetworkFoundInd)
13227 {
13228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13229 "Memory allocation failure, "
13230 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13231 if (NULL !=
13232 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13233 {
13234 wpalMemoryFree(
13235 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13236 );
13237 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13239 break;
13240 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13241 /* Message Header */
13242 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13243 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13244
13245 /* Info from WDI Indication */
13246 pPrefNetworkFoundInd->ssId.length =
13247 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13248 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13249 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13250 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13251 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13252 if (NULL !=
13253 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13254 {
13255 pPrefNetworkFoundInd->frameLength =
13256 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13257 vos_mem_copy( pPrefNetworkFoundInd->data,
13258 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13259 pPrefNetworkFoundInd->frameLength);
13260 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13261 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13262 }
13263 else
13264 {
13265 pPrefNetworkFoundInd->frameLength = 0;
13266 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13267 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13268 /* VOS message wrapper */
13269 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13270 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13271 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13272 /* Send message to SME */
13273 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13274 {
13275 /* free the mem and return */
13276 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13277 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13278 break;
13279 }
13280#endif // FEATURE_WLAN_SCAN_PNO
13281
13282#ifdef WLAN_WAKEUP_EVENTS
13283 case WDI_WAKE_REASON_IND:
13284 {
13285 vos_msg_t vosMsg;
13286 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13287 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13288 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13289
13290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13291 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13292 wdiLowLevelInd->wdiIndicationType,
13293 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13294 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13295 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13296
13297 if (NULL == pWakeReasonInd)
13298 {
13299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13300 "Memory allocation failure, "
13301 "WDI_WAKE_REASON_IND not forwarded");
13302 break;
13303 }
13304
13305 vos_mem_zero(pWakeReasonInd, allocSize);
13306
13307 /* Message Header */
13308 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13309 pWakeReasonInd->mesgLen = allocSize;
13310
13311 /* Info from WDI Indication */
13312 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13313 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13314 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13315 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13316 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13317 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13318 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13319 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13320
13321 /* VOS message wrapper */
13322 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13323 vosMsg.bodyptr = (void *) pWakeReasonInd;
13324 vosMsg.bodyval = 0;
13325
13326 /* Send message to SME */
13327 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13328 {
13329 /* free the mem and return */
13330 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13331 }
13332
13333 break;
13334 }
13335#endif // WLAN_WAKEUP_EVENTS
13336
13337 case WDI_TX_PER_HIT_IND:
13338 {
13339 vos_msg_t vosMsg;
13340 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13341 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13342 /* VOS message wrapper */
13343 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13344 vosMsg.bodyptr = NULL;
13345 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13346 /* Send message to SME */
13347 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13348 {
13349 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13350 }
13351 break;
13352 }
13353
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13354#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13355 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13356 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13357 vos_msg_t vosMsg;
13358 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13359
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13360 lphbInd =
13361 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13362 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13363 {
13364 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13365 "%s: LPHB IND buffer alloc Fail", __func__);
13366 return ;
13367 }
13368
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13369 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13370 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13371 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13372 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13373 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13374 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13375
13376 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13377 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13378 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13379
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13380 vosMsg.type = eWNI_SME_LPHB_IND;
13381 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13382 vosMsg.bodyval = 0;
13383 /* Send message to SME */
13384 if (VOS_STATUS_SUCCESS !=
13385 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13386 {
13387 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13388 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13389 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13390 }
13391 break;
13392 }
13393#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13394 case WDI_PERIODIC_TX_PTRN_FW_IND:
13395 {
13396 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13397 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13398 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13399 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13400 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13401 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13402 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13403
13404 break;
13405 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13406
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13407 case WDI_IBSS_PEER_INACTIVITY_IND:
13408 {
13409 tSirIbssPeerInactivityInd *pIbssInd =
13410 (tSirIbssPeerInactivityInd *)
13411 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13412
13413 if (NULL == pIbssInd)
13414 {
13415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13416 "Memory allocation failure, "
13417 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13418 break;
13419 }
13420
13421 pIbssInd->bssIdx =
13422 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13423 pIbssInd->staIdx =
13424 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13425 vos_mem_copy(pIbssInd->peerAddr,
13426 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13427 sizeof(tSirMacAddr));
13428 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13429 break;
13430 }
13431
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13432#ifdef FEATURE_WLAN_BATCH_SCAN
13433 case WDI_BATCH_SCAN_RESULT_IND:
13434 {
13435 void *pBatchScanResult;
13436 void *pCallbackContext;
13437 tpAniSirGlobal pMac;
13438
13439 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13440 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13441
13442 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13443 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13444 {
13445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13446 "%s:pWDA is NULL", __func__);
13447 VOS_ASSERT(0);
13448 return;
13449 }
13450
13451 pBatchScanResult =
13452 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13453 if (NULL == pBatchScanResult)
13454 {
13455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13456 "%s:Batch scan result from FW is null can't invoke HDD callback",
13457 __func__);
13458 VOS_ASSERT(0);
13459 return;
13460 }
13461
13462 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13463 if (NULL == pMac)
13464 {
13465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13466 "%s:pMac is NULL", __func__);
13467 VOS_ASSERT(0);
13468 return;
13469 }
13470
13471 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13472 /*call hdd callback with set batch scan response data*/
13473 if(pMac->pmc.batchScanResultCallback)
13474 {
13475 pMac->pmc.batchScanResultCallback(pCallbackContext,
13476 pBatchScanResult);
13477 }
13478 else
13479 {
13480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13481 "%s:HDD callback is null", __func__);
13482 VOS_ASSERT(0);
13483 }
13484 break;
13485 }
13486#endif
13487
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13488#ifdef FEATURE_WLAN_CH_AVOID
13489 case WDI_CH_AVOID_IND:
13490 {
13491 vos_msg_t vosMsg;
13492 tSirChAvoidIndType *chAvoidInd;
13493
13494 chAvoidInd =
13495 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13496 if (NULL == chAvoidInd)
13497 {
13498 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13499 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13500 return ;
13501 }
13502
13503 chAvoidInd->avoidRangeCount =
13504 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13505 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13506 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13507 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13508
13509 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13510 "%s : WDA CH avoid notification", __func__);
13511
13512 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13513 vosMsg.bodyptr = chAvoidInd;
13514 vosMsg.bodyval = 0;
13515 /* Send message to SME */
13516 if (VOS_STATUS_SUCCESS !=
13517 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13518 {
13519 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13520 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13521 vos_mem_free(chAvoidInd);
13522 }
13523 break;
13524 }
13525#endif /* FEATURE_WLAN_CH_AVOID */
13526
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13527#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13528 case WDI_LL_STATS_RESULTS_IND:
13529 {
13530 void *pLinkLayerStatsInd;
13531 void *pCallbackContext;
13532 tpAniSirGlobal pMac;
13533
13534 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13535 "Received WDI_LL_STATS_RESULTS_IND from FW");
13536
13537 /*sanity check*/
13538 if (NULL == pWDA)
13539 {
13540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13541 "%s:pWDA is NULL", __func__);
13542 VOS_ASSERT(0);
13543 return;
13544 }
13545
13546 pLinkLayerStatsInd =
13547 (void *)wdiLowLevelInd->wdiIndicationData.pLinkLayerStatsResults;
13548 if (NULL == pLinkLayerStatsInd)
13549 {
13550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13551 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13552 __func__);
13553 VOS_ASSERT(0);
13554 return;
13555 }
13556
13557 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13558 if (NULL == pMac)
13559 {
13560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13561 "%s:pMac is NULL", __func__);
13562 VOS_ASSERT(0);
13563 return;
13564 }
13565
13566 pCallbackContext = pMac->sme.pLinkLayerStatsCallbackContext;
13567 /*call hdd callback with Link Layer Statistics*/
13568 if (pMac->sme.pLinkLayerStatsIndCallback)
13569 {
13570 pMac->sme.pLinkLayerStatsIndCallback(pCallbackContext,
13571 WDA_LINK_LAYER_STATS_RESULTS_RSP,
13572 pLinkLayerStatsInd);
13573 }
13574 else
13575 {
13576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13577 "%s:HDD callback is null", __func__);
13578 }
13579 break;
13580 }
13581#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13582
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13583#ifdef WLAN_FEATURE_EXTSCAN
13584 case WDI_EXTSCAN_PROGRESS_IND:
13585 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13586 case WDI_EXTSCAN_SCAN_RESULT_IND:
13587 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13588 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13589 {
13590 void *pEXTScanData;
13591 void *pCallbackContext;
13592 tpAniSirGlobal pMac;
13593 tANI_U16 indType;
13594
13595 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13596 "Received WDI_EXTSCAN Indications from FW");
13597 /*sanity check*/
13598 if (NULL == pWDA)
13599 {
13600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13601 "%s:pWDA is NULL", __func__);
13602 VOS_ASSERT(0);
13603 return;
13604 }
13605 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
13606 {
13607 indType = WDA_EXTSCAN_PROGRESS_IND;
13608
13609 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13610 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
13611 }
13612 if (wdiLowLevelInd->wdiIndicationType ==
13613 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
13614 {
13615 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
13616
13617 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13618 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
13619 }
13620 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
13621 {
13622 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
13623
13624 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13625 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
13626 }
13627 if (wdiLowLevelInd->wdiIndicationType ==
13628 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
13629 {
13630 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
13631
13632 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13633 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
13634 }
13635 if (wdiLowLevelInd->wdiIndicationType ==
13636 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
13637 {
13638 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
13639
13640 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13641 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
13642 }
13643
13644 pEXTScanData =
13645 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
13646 if (NULL == pEXTScanData)
13647 {
13648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13649 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
13650 __func__);
13651 VOS_ASSERT(0);
13652 return;
13653 }
13654
13655 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13656 if (NULL == pMac)
13657 {
13658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13659 "%s:pMac is NULL", __func__);
13660 VOS_ASSERT(0);
13661 return;
13662 }
13663
13664 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
13665
13666 if(pMac->sme.pEXTScanIndCb)
13667 {
13668 pMac->sme.pEXTScanIndCb(pCallbackContext,
13669 indType,
13670 pEXTScanData);
13671 }
13672 else
13673 {
13674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13675 "%s:HDD callback is null", __func__);
13676 }
13677 break;
13678 }
13679#endif /* WLAN_FEATURE_EXTSCAN */
13680
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13681 default:
13682 {
13683 /* TODO error */
13684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13685 "Received UNKNOWN Indication from WDI ");
13686 }
13687 }
13688 return ;
13689}
13690
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13691/*
13692 * BA related processing in WDA.
13693 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13694void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
13695 void* pUserData)
13696{
13697 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13698 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13699 if(NULL == pWdaParams)
13700 {
13701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13702 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13703 VOS_ASSERT(0) ;
13704 return ;
13705 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13706 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13707 vos_mem_free(pWdaParams->wdaMsgParam) ;
13708 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13709 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13711 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13712 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
13713 {
13714 tANI_U8 i = 0 ;
13715 tBaActivityInd *baActivityInd = NULL ;
13716 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
13717 tANI_U8 allocSize = sizeof(tBaActivityInd)
13718 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
13719 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
13720 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13721 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13722 if(NULL == baActivityInd)
13723 {
13724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13725 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13726 VOS_ASSERT(0) ;
13727 return;
13728 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13729 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
13730 sizeof(tSirMacAddr)) ;
13731 baActivityInd->baCandidateCnt = baCandidateCount ;
13732
13733 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
13734 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
13735
13736 for(i = 0 ; i < baCandidateCount ; i++)
13737 {
13738 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13739 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
13740 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13741 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
13742 {
13743 baCandidate->baInfo[tid].fBaEnable =
13744 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
13745 baCandidate->baInfo[tid].startingSeqNum =
13746 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
13747 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]13748 wdiBaCandidate++ ;
13749 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13751 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
13752 }
13753 else
13754 {
13755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13756 "BA Trigger RSP with Failure received ");
13757 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13758 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13759}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13760
13761
13762/*
13763 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
13764 * during MCC
13765 */
13766void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
13767{
13768 wpt_uint32 enabled;
13769 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
13770 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
13771 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
13772
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13773 if (NULL == pMac )
13774 {
13775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13776 "%s: Invoked with invalid MAC context ", __func__ );
13777 VOS_ASSERT(0);
13778 return;
13779 }
13780
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13781 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13782 != eSIR_SUCCESS)
13783 {
13784 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13785 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13786 return;
13787 }
13788
13789 if(!enabled)
13790 {
13791 return;
13792 }
13793
13794 if(NULL == pWDA)
13795 {
13796 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13797 "%s:WDA context is NULL", __func__);
13798 VOS_ASSERT(0);
13799 return;
13800 }
13801
13802 if(activate)
13803 {
13804 if( VOS_STATUS_SUCCESS !=
13805 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13806 {
13807 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13808 "Traffic Stats Timer Start Failed ");
13809 return;
13810 }
13811 WDI_DS_ActivateTrafficStats();
13812 }
13813 else
13814 {
13815 WDI_DS_DeactivateTrafficStats();
13816 WDI_DS_ClearTrafficStats();
13817
13818 if( VOS_STATUS_SUCCESS !=
13819 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13820 {
13821 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13822 "Traffic Stats Timer Stop Failed ");
13823 return;
13824 }
13825 }
13826}
13827
13828/*
13829 * Traffic Stats Timer handler
13830 */
13831void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
13832{
13833 WDI_Status wdiStatus;
13834 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
13835 WDI_TrafficStatsIndType trafficStatsIndParams;
13836 wpt_uint32 length, enabled;
13837 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13838
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13839 if (NULL == pMac )
13840 {
13841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13842 "%s: Invoked with invalid MAC context ", __func__ );
13843 VOS_ASSERT(0);
13844 return;
13845 }
13846
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13847 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13848 != eSIR_SUCCESS)
13849 {
13850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13851 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13852 return;
13853 }
13854
13855 if(!enabled)
13856 {
13857 WDI_DS_DeactivateTrafficStats();
13858 return;
13859 }
13860
13861 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
13862
13863 if(pWdiTrafficStats != NULL)
13864 {
13865 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
13866 trafficStatsIndParams.length = length;
13867 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]13868 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13869 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13870 trafficStatsIndParams.pUserData = pWDA;
13871
13872 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
13873
13874 if(WDI_STATUS_PENDING == wdiStatus)
13875 {
13876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13877 "Pending received for %s:%d ",__func__,__LINE__ );
13878 }
13879 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
13880 {
13881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13882 "Failure in %s:%d ",__func__,__LINE__ );
13883 }
13884
13885 WDI_DS_ClearTrafficStats();
13886 }
13887 else
13888 {
13889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13890 "pWdiTrafficStats is Null");
13891 }
13892
13893 if( VOS_STATUS_SUCCESS !=
13894 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13895 {
13896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13897 "Traffic Stats Timer Start Failed ");
13898 return;
13899 }
13900}
13901
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13902/*
13903 * BA Activity check timer handler
13904 */
13905void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
13906{
13907 tANI_U8 curSta = 0 ;
13908 tANI_U8 tid = 0 ;
13909 tANI_U8 size = 0 ;
13910 tANI_U8 baCandidateCount = 0 ;
13911 tANI_U8 newBaCandidate = 0 ;
13912 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
13913
13914 if(NULL == pWDA)
13915 {
13916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13917 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13918 VOS_ASSERT(0);
13919 return ;
13920 }
13921 if(WDA_MAX_STA < pWDA->wdaMaxSta)
13922 {
13923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13924 "Inconsistent STA entries in WDA");
13925 VOS_ASSERT(0) ;
13926 }
13927 /* walk through all STA entries and find out TX packet count */
13928 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
13929 {
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]13930#ifdef WLAN_SOFTAP_VSTA_FEATURE
13931 // We can only do BA on "hard" STAs.
13932 if (!(IS_HWSTA_IDX(curSta)))
13933 {
13934 continue;
13935 }
13936#endif //WLAN_SOFTAP_VSTA_FEATURE
13937 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
13938 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13939 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13940 tANI_U32 txPktCount = 0 ;
13941 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13942 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13943 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
13944 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13945 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
13946 curSta, tid, &txPktCount)))
13947 {
13948#if 0
13949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
13950 "************* %d:%d, %d ",curSta, txPktCount,
13951 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
13952#endif
13953 if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13954 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13955 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
13956 curSta, tid)))
13957 {
13958 /* get prepare for sending message to HAL */
13959 //baCandidate[baCandidateCount].staIdx = curSta ;
13960 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
13961 newBaCandidate = WDA_ENABLE_BA ;
13962 }
13963 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
13964 }
13965 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13966 /* fill the entry for all the sta with given TID's */
13967 if(WDA_ENABLE_BA == newBaCandidate)
13968 {
13969 /* move to next BA candidate */
13970 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
13971 size += sizeof(WDI_TriggerBAReqCandidateType) ;
13972 baCandidateCount++ ;
13973 newBaCandidate = WDA_DISABLE_BA ;
13974 }
13975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13976 /* prepare and send message to hal */
13977 if( 0 < baCandidateCount)
13978 {
13979 WDI_Status status = WDI_STATUS_SUCCESS ;
13980 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
13981 tWDA_ReqParams *pWdaParams =
13982 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13983 if(NULL == pWdaParams)
13984 {
13985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13986 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13987 VOS_ASSERT(0) ;
13988 return;
13989 }
13990 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
13991 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
13992 if(NULL == wdiTriggerBaReq)
13993 {
13994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13995 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13996 VOS_ASSERT(0) ;
13997 vos_mem_free(pWdaParams);
13998 return;
13999 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14000 do
14001 {
14002 WDI_TriggerBAReqinfoType *triggerBaInfo =
14003 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14004 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14005 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14006 * for each request */
14007 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14008 triggerBaInfo->ucBASessionID = 0;
14009 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14010 } while(0) ;
14011 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14013 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14014 pWdaParams->pWdaContext = pWDA;
14015 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14016 pWdaParams->wdaMsgParam = NULL;
14017 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14018 WDA_TriggerBaReqCallback, pWdaParams) ;
14019 if(IS_WDI_STATUS_FAILURE(status))
14020 {
14021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14022 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14023 vos_mem_free(pWdaParams->wdaMsgParam) ;
14024 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14025 vos_mem_free(pWdaParams) ;
14026 }
14027 }
14028 else
14029 {
14030 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14031 "There is no TID for initiating BA");
14032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14033 if( VOS_STATUS_SUCCESS !=
14034 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14035 {
14036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14037 "BA Activity Timer Stop Failed ");
14038 return ;
14039 }
14040 if( VOS_STATUS_SUCCESS !=
14041 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14042 {
14043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14044 "BA Activity Timer Start Failed ");
14045 return;
14046 }
14047 return ;
14048}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14049/*
14050 * WDA common routine to create timer used by WDA.
14051 */
14052static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14053{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14054 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14055 tANI_U32 val = 0 ;
14056 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14057
14058 if(NULL == pMac)
14059 {
14060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14061 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14062 VOS_ASSERT(0);
14063 return VOS_STATUS_E_FAILURE;
14064 }
14065 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14066 != eSIR_SUCCESS)
14067 {
14068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14069 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14070 return VOS_STATUS_E_FAILURE;
14071 }
14072 val = SYS_MS_TO_TICKS(val) ;
14073
14074 /* BA activity check timer */
14075 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14076 "BA Activity Check timer", WDA_TimerHandler,
14077 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14078 if(status != TX_SUCCESS)
14079 {
14080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14081 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14082 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14083 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14084 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14085 /* Tx Complete Timeout timer */
14086 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14087 "Tx Complete Check timer", WDA_TimerHandler,
14088 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14089 if(status != TX_SUCCESS)
14090 {
14091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14092 "Unable to create Tx Complete Timeout timer");
14093 /* Destroy timer of BA activity check timer */
14094 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14095 if(status != TX_SUCCESS)
14096 {
14097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14098 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14099 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14100 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14101 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14102 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14103
14104 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14105
14106 /* Traffic Stats timer */
14107 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14108 "Traffic Stats timer", WDA_TimerHandler,
14109 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14110 if(status != TX_SUCCESS)
14111 {
14112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14113 "Unable to create traffic stats timer");
14114 /* Destroy timer of BA activity check timer */
14115 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14116 if(status != TX_SUCCESS)
14117 {
14118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14119 "Unable to Destroy BA activity timer");
14120 }
14121 /* Destroy timer of tx complete timer */
14122 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14123 if(status != TX_SUCCESS)
14124 {
14125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14126 "Unable to Tx complete timer");
14127 }
14128 return VOS_STATUS_E_FAILURE ;
14129 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14130 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14131}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14132/*
14133 * WDA common routine to destroy timer used by WDA.
14134 */
14135static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14136{
14137 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14138 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14139 if(status != TX_SUCCESS)
14140 {
14141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14142 "Unable to Destroy Tx Complete Timeout timer");
14143 return eSIR_FAILURE ;
14144 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14145 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14146 if(status != TX_SUCCESS)
14147 {
14148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14149 "Unable to Destroy BA activity timer");
14150 return eSIR_FAILURE ;
14151 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14152 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14153 if(status != TX_SUCCESS)
14154 {
14155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14156 "Unable to Destroy traffic stats timer");
14157 return eSIR_FAILURE ;
14158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14159 return eSIR_SUCCESS ;
14160}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14161/*
14162 * WDA timer handler.
14163 */
14164void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14165{
14166 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14167 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14168 /*
14169 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14170 */
14171 wdaMsg.type = timerInfo ;
14172 wdaMsg.bodyptr = NULL;
14173 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14174 /* post the message.. */
14175 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14176 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14177 {
14178 vosStatus = VOS_STATUS_E_BADMSG;
14179 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14180}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14181/*
14182 * WDA Tx Complete timeout Indication.
14183 */
14184void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14185{
14186 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14187 if( pWDA->pAckTxCbFunc )
14188 {
14189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14190 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14191 pWDA->pAckTxCbFunc( pMac, 0);
14192 pWDA->pAckTxCbFunc = NULL;
14193 }
14194 else
14195 {
14196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14197 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14198 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14199}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14200/*
14201 * WDA Set REG Domain to VOS NV
14202 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14203eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14204 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14205{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14206 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14207 {
14208 return eHAL_STATUS_INVALID_PARAMETER;
14209 }
14210 return eHAL_STATUS_SUCCESS;
14211}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14212
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14213#ifdef FEATURE_WLAN_SCAN_PNO
14214/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14215 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14216 *
14217 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14218void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14219{
14220 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14221 tSirPNOScanReq *pPNOScanReqParams;
14222
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14224 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14225 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14226 {
14227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14228 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14229 VOS_ASSERT(0) ;
14230 return ;
14231 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14232
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14233 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14234 if(pPNOScanReqParams->statusCallback)
14235 {
14236 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14237 (status == WDI_STATUS_SUCCESS) ?
14238 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14239 }
14240
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14242 vos_mem_free(pWdaParams->wdaMsgParam);
14243 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14244
14245 return ;
14246}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14247/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14248 * FUNCTION: WDA_PNOScanReqCallback
14249 * Free memory.
14250 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14251 */
14252void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14253{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14254 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14255 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14256
14257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14258 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14259
14260 if(NULL == pWdaParams)
14261 {
14262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14263 "%s: pWdaParams received NULL", __func__);
14264 VOS_ASSERT(0);
14265 return;
14266 }
14267
14268 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14269 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14270 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14271 if(pPNOScanReqParams->statusCallback)
14272 {
14273 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14274 VOS_STATUS_E_FAILURE);
14275 }
14276
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14277 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14278 vos_mem_free(pWdaParams->wdaMsgParam);
14279 vos_mem_free(pWdaParams);
14280 }
14281
14282 return;
14283}
14284/*
14285 * FUNCTION: WDA_UpdateScanParamsRespCallback
14286 *
14287 */
14288void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14289{
14290 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14292 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14293 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14294 {
14295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14296 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14297 VOS_ASSERT(0) ;
14298 return ;
14299 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14300
14301 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14302 vos_mem_free(pWdaParams->wdaMsgParam);
14303 vos_mem_free(pWdaParams);
14304
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14305 return ;
14306}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14307/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14308 * FUNCTION: WDA_UpdateScanParamsReqCallback
14309 * Free memory.
14310 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14311 */
14312void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14313{
14314 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14315
14316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14317 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14318
14319 if(NULL == pWdaParams)
14320 {
14321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14322 "%s: pWdaParams received NULL", __func__);
14323 VOS_ASSERT(0);
14324 return;
14325 }
14326
14327 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14328 {
14329 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14330 vos_mem_free(pWdaParams->wdaMsgParam);
14331 vos_mem_free(pWdaParams);
14332 }
14333
14334 return;
14335}
14336/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14337 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14338 * Request to WDI to set Preferred Network List.Offload
14339 */
14340VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14341 tSirPNOScanReq *pPNOScanReqParams)
14342{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14343 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14344 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14345 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14346 tWDA_ReqParams *pWdaParams ;
14347 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14349 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14350 if(NULL == pwdiPNOScanReqInfo)
14351 {
14352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14353 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14354 VOS_ASSERT(0);
14355 return VOS_STATUS_E_NOMEM;
14356 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14357 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14358 if(NULL == pWdaParams)
14359 {
14360 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14361 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14362 VOS_ASSERT(0);
14363 vos_mem_free(pwdiPNOScanReqInfo);
14364 return VOS_STATUS_E_NOMEM;
14365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14366 //
14367 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14368 //
14369 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14370 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14371 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14372 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14373 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14374 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14375 {
14376 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14377 &pPNOScanReqParams->aNetworks[i],
14378 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14379 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14380 /*Scan timer intervals*/
14381 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14382 &pPNOScanReqParams->scanTimers,
14383 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14384 /*Probe template for 2.4GHz band*/
14385 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14386 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14387 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14388 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14389 pPNOScanReqParams->p24GProbeTemplate,
14390 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14391 /*Probe template for 5GHz band*/
14392 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14393 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14394 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14395 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14396 pPNOScanReqParams->p5GProbeTemplate,
14397 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14398 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14399 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14400
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14401 /* Store Params pass it to WDI */
14402 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14403 pWdaParams->pWdaContext = pWDA;
14404 /* Store param pointer as passed in by caller */
14405 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14406 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14407 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14408 if(IS_WDI_STATUS_FAILURE(status))
14409 {
14410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14411 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14412 if(pPNOScanReqParams->statusCallback)
14413 {
14414 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14415 VOS_STATUS_E_FAILURE);
14416 }
14417
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14418 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14419 vos_mem_free(pWdaParams->wdaMsgParam);
14420 pWdaParams->wdaWdiApiMsgParam = NULL;
14421 pWdaParams->wdaMsgParam = NULL;
14422 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14423 return CONVERT_WDI2VOS_STATUS(status) ;
14424}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14425
14426#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14427
14428void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14429{
14430 /*Convert the CSR Auth types to WDI Auth types */
14431 switch (csrAuthType)
14432 {
14433 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14434 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14435 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14436#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14437 case eCSR_AUTH_TYPE_CCKM_WPA:
14438 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14439 break;
14440#endif
14441 case eCSR_AUTH_TYPE_WPA:
14442 *AuthType = eWDA_AUTH_TYPE_WPA;
14443 break;
14444 case eCSR_AUTH_TYPE_WPA_PSK:
14445 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14446 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14447#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14448 case eCSR_AUTH_TYPE_CCKM_RSN:
14449 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14450 break;
14451#endif
14452 case eCSR_AUTH_TYPE_RSN:
14453 *AuthType = eWDA_AUTH_TYPE_RSN;
14454 break;
14455 case eCSR_AUTH_TYPE_RSN_PSK:
14456 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14457 break;
14458#if defined WLAN_FEATURE_VOWIFI_11R
14459 case eCSR_AUTH_TYPE_FT_RSN:
14460 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14461 break;
14462 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14463 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14464 break;
14465#endif
14466#ifdef FEATURE_WLAN_WAPI
14467 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14468 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14469 break;
14470 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14471 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14472 break;
14473#endif /* FEATURE_WLAN_WAPI */
14474 case eCSR_AUTH_TYPE_SHARED_KEY:
14475 case eCSR_AUTH_TYPE_AUTOSWITCH:
14476 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14477 break;
14478#if 0
14479 case eCSR_AUTH_TYPE_SHARED_KEY:
14480 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14481 break;
14482 case eCSR_AUTH_TYPE_AUTOSWITCH:
14483 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14484#endif
14485 default:
14486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14487 "%s: Unknown Auth Type", __func__);
14488 break;
14489 }
14490}
14491void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14492{
14493 switch (csrEncrType)
14494 {
14495 case eCSR_ENCRYPT_TYPE_NONE:
14496 *EncrType = WDI_ED_NONE;
14497 break;
14498 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14499 case eCSR_ENCRYPT_TYPE_WEP40:
14500 *EncrType = WDI_ED_WEP40;
14501 break;
14502 case eCSR_ENCRYPT_TYPE_WEP104:
14503 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14504 *EncrType = WDI_ED_WEP104;
14505 break;
14506 case eCSR_ENCRYPT_TYPE_TKIP:
14507 *EncrType = WDI_ED_TKIP;
14508 break;
14509 case eCSR_ENCRYPT_TYPE_AES:
14510 *EncrType = WDI_ED_CCMP;
14511 break;
14512#ifdef WLAN_FEATURE_11W
14513 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14514 *EncrType = WDI_ED_AES_128_CMAC;
14515 break;
14516#endif
14517#ifdef FEATURE_WLAN_WAPI
14518 case eCSR_ENCRYPT_TYPE_WPI:
14519 *EncrType = WDI_ED_WPI;
14520 break;
14521#endif
14522 case eCSR_ENCRYPT_TYPE_ANY:
14523 *EncrType = WDI_ED_ANY;
14524 break;
14525
14526 default:
14527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14528 "%s: Unknown Encryption Type", __func__);
14529 break;
14530 }
14531}
14532
14533/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14534 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14535 * Request to WDI to set Roam Offload Scan
14536 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14537VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14538 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
14539{
14540 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14541 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
14542 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14543 tWDA_ReqParams *pWdaParams ;
14544 v_U8_t csrAuthType;
14545 WDI_RoamNetworkType *pwdiRoamNetworkType;
14546 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
14547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14548 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14549 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14550 {
14551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14552 "%s: VOS MEM Alloc Failure", __func__);
14553 VOS_ASSERT(0);
14554 return VOS_STATUS_E_NOMEM;
14555 }
14556 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14557 if (NULL == pWdaParams)
14558 {
14559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14560 "%s: VOS MEM Alloc Failure", __func__);
14561 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14562 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14563 return VOS_STATUS_E_NOMEM;
14564 }
14565
14566 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14567 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14568 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14569 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
14570 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14571 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
14572 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
14573 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
14574 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
14575 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
14576 sizeof(pwdiRoamNetworkType->currAPbssid));
14577 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
14578 csrAuthType);
14579 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
14580 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
14581 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
14582 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
14583 pwdiRoamOffloadScanInfo->LookupThreshold =
14584 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]14585 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
14586 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14587 pwdiRoamOffloadScanInfo->RoamRssiDiff =
14588 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]14589 pwdiRoamOffloadScanInfo->MAWCEnabled =
14590 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14591 pwdiRoamOffloadScanInfo->Command =
14592 pRoamOffloadScanReqParams->Command ;
14593 pwdiRoamOffloadScanInfo->StartScanReason =
14594 pRoamOffloadScanReqParams->StartScanReason ;
14595 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
14596 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
14597 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
14598 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
14599 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
14600 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
14601 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
14602 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
14603 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
14604 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14605 pwdiRoamOffloadScanInfo->IsESEEnabled =
14606 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14607 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
14608 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
14609 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
14610 pwdiRoamNetworkType->ssId.ucLength =
14611 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
14612 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
14613 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
14614 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
14615 pwdiRoamNetworkType->ChannelCount =
14616 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
14617 pwdiRoamOffloadScanInfo->ChannelCacheType =
14618 pRoamOffloadScanReqParams->ChannelCacheType;
14619 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
14620 pRoamOffloadScanReqParams->ValidChannelList,
14621 pRoamOffloadScanReqParams->ValidChannelCount);
14622 pwdiRoamOffloadScanInfo->ValidChannelCount =
14623 pRoamOffloadScanReqParams->ValidChannelCount;
14624 pwdiRoamOffloadScanInfo->us24GProbeSize =
14625 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14626 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14627 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
14628 pRoamOffloadScanReqParams->p24GProbeTemplate,
14629 pwdiRoamOffloadScanInfo->us24GProbeSize);
14630 pwdiRoamOffloadScanInfo->us5GProbeSize =
14631 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14632 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14633 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
14634 pRoamOffloadScanReqParams->p5GProbeTemplate,
14635 pwdiRoamOffloadScanInfo->us5GProbeSize);
14636 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
14637 pRoamOffloadScanReqParams->MDID.mdiePresent;
14638 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
14639 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14640 pwdiRoamOffloadScanInfo->nProbes =
14641 pRoamOffloadScanReqParams->nProbes;
14642 pwdiRoamOffloadScanInfo->HomeAwayTime =
14643 pRoamOffloadScanReqParams->HomeAwayTime;
14644 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14645 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14646 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14647 pWdaParams->pWdaContext = pWDA;
14648 /* Store param pointer as passed in by caller */
14649 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14650 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14651 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
14652 if(IS_WDI_STATUS_FAILURE(status))
14653 {
14654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14655 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
14656 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14657 vos_mem_free(pWdaParams->wdaMsgParam);
14658 pWdaParams->wdaWdiApiMsgParam = NULL;
14659 pWdaParams->wdaMsgParam = NULL;
14660 }
14661 return CONVERT_WDI2VOS_STATUS(status) ;
14662}
14663#endif
14664
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14665/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14666 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14667 *
14668 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14669void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14670{
14671 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14672
14673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14674 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14675
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14676 if(NULL == pWdaParams)
14677 {
14678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14679 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14680 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14681 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14682 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14683
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14684 vos_mem_free(pWdaParams->wdaMsgParam) ;
14685 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14686 vos_mem_free(pWdaParams) ;
14687
14688 return ;
14689}
14690/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14691 * FUNCTION: WDA_RssiFilterReqCallback
14692 * Free memory.
14693 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
14694 */
14695void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
14696{
14697 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14698
14699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14700 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14701
14702 if(NULL == pWdaParams)
14703 {
14704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14705 "%s: pWdaParams received NULL", __func__);
14706 VOS_ASSERT(0);
14707 return;
14708 }
14709
14710 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14711 {
14712 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14713 vos_mem_free(pWdaParams->wdaMsgParam);
14714 vos_mem_free(pWdaParams);
14715 }
14716
14717 return;
14718}
14719/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14720 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14721 * Request to WDI to set Preferred Network List.Offload
14722 */
14723VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
14724 tSirSetRSSIFilterReq* pRssiFilterParams)
14725{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14726 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14727 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
14728 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
14729 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14731 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14732 if(NULL == pwdiSetRssiFilterReqInfo)
14733 {
14734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14735 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14736 VOS_ASSERT(0);
14737 return VOS_STATUS_E_NOMEM;
14738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14739 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14740 if(NULL == pWdaParams)
14741 {
14742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14743 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14744 VOS_ASSERT(0);
14745 vos_mem_free(pwdiSetRssiFilterReqInfo);
14746 return VOS_STATUS_E_NOMEM;
14747 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14748 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14749 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
14750 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14751
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14752 /* Store Params pass it to WDI */
14753 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
14754 pWdaParams->pWdaContext = pWDA;
14755 /* Store param pointer as passed in by caller */
14756 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14757 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14758 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14759 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14760 if(IS_WDI_STATUS_FAILURE(status))
14761 {
14762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14763 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
14764 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14765 vos_mem_free(pWdaParams->wdaMsgParam);
14766 pWdaParams->wdaWdiApiMsgParam = NULL;
14767 pWdaParams->wdaMsgParam = NULL;
14768 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14769 return CONVERT_WDI2VOS_STATUS(status) ;
14770}
14771
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14772/*
14773 * FUNCTION: WDA_ProcessUpdateScanParams
14774 * Request to WDI to update Scan Parameters
14775 */
14776VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
14777 tSirUpdateScanParams *pUpdateScanParams)
14778{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14779 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14780 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
14781 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
14782 sizeof(WDI_UpdateScanParamsInfoType)) ;
14783 tWDA_ReqParams *pWdaParams ;
14784 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14786 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14787 if(NULL == wdiUpdateScanParamsInfoType)
14788 {
14789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14790 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14791 VOS_ASSERT(0);
14792 return VOS_STATUS_E_NOMEM;
14793 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14794 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14795 if ( NULL == pWdaParams )
14796 {
14797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14798 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14799 VOS_ASSERT(0);
14800 vos_mem_free(wdiUpdateScanParamsInfoType);
14801 return VOS_STATUS_E_NOMEM;
14802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14803 //
14804 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
14805 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14807 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
14808 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
14809 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]14810 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14811 pUpdateScanParams->b11dEnabled,
14812 pUpdateScanParams->b11dResolved,
14813 pUpdateScanParams->ucChannelCount,
14814 pUpdateScanParams->usPassiveMinChTime,
14815 pUpdateScanParams->usPassiveMaxChTime,
14816 pUpdateScanParams->usActiveMinChTime,
14817 pUpdateScanParams->usActiveMaxChTime,
14818 sizeof(tSirUpdateScanParams),
14819 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
14820
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14821 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
14822 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14823 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
14824 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14825 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
14826 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14827 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
14828 pUpdateScanParams->usActiveMaxChTime;
14829 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
14830 pUpdateScanParams->usActiveMinChTime;
14831 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
14832 pUpdateScanParams->usPassiveMaxChTime;
14833 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
14834 pUpdateScanParams->usPassiveMinChTime;
14835
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14836 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]14837 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
14838 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14839
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14840 for ( i = 0; i <
14841 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
14842 i++)
14843 {
14844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14845 "Update Scan Parameters channel: %d",
14846 pUpdateScanParams->aChannels[i]);
14847
14848 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
14849 pUpdateScanParams->aChannels[i];
14850 }
14851
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14852 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
14853 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14854
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14855 /* Store Params pass it to WDI */
14856 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
14857 pWdaParams->pWdaContext = pWDA;
14858 /* Store param pointer as passed in by caller */
14859 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14860
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14861
14862
14863 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14864 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14865 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14866 if(IS_WDI_STATUS_FAILURE(status))
14867 {
14868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14869 "Failure in Update Scan Params EQ WDI API, free all the memory " );
14870 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14871 vos_mem_free(pWdaParams->wdaMsgParam);
14872 vos_mem_free(pWdaParams);
14873 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14874 return CONVERT_WDI2VOS_STATUS(status) ;
14875}
14876#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14877
14878#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14879/*
14880 * FUNCTION: WDA_RoamOffloadScanReqCallback
14881 *
14882 */
14883void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
14884{
14885 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14886 vos_msg_t vosMsg;
14887 wpt_uint8 reason = 0;
14888
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]14889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14890 "<------ %s " ,__func__);
14891 if (NULL == pWdaParams)
14892 {
14893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14894 "%s: pWdaParams received NULL", __func__);
14895 VOS_ASSERT(0) ;
14896 return ;
14897 }
14898 if ( pWdaParams != NULL )
14899 {
14900 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
14901 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14902 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14903 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14904 }
14905 if ( pWdaParams->wdaMsgParam != NULL)
14906 {
14907 vos_mem_free(pWdaParams->wdaMsgParam);
14908 }
14909
14910 vos_mem_free(pWdaParams) ;
14911 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14912 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
14913 vosMsg.bodyptr = NULL;
14914 if (WDI_STATUS_SUCCESS != status)
14915 {
14916 reason = 0;
14917 }
14918 vosMsg.bodyval = reason;
14919 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
14920 {
14921 /* free the mem and return */
14922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]14923 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14924 }
14925
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14926 return ;
14927}
14928#endif
14929
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14930/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14931 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14932 *
14933 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14934void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14935{
14936 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14937
14938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14939 "<------ %s " ,__func__);
14940
14941 if(NULL == pWdaParams)
14942 {
14943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14944 "%s: pWdaParams received NULL", __func__);
14945 VOS_ASSERT(0);
14946 return;
14947 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14948
14949 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14950 vos_mem_free(pWdaParams->wdaMsgParam);
14951 vos_mem_free(pWdaParams);
14952
14953 return;
14954}
14955/*
14956 * FUNCTION: WDA_SetPowerParamsReqCallback
14957 * Free memory.
14958 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
14959 */
14960void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14961{
14962 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14963
14964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14965 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14966
14967 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14968 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14970 "%s: pWdaParams received NULL", __func__);
14971 VOS_ASSERT(0);
14972 return;
14973 }
14974
14975 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14976 {
14977 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14978 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14979 vos_mem_free(pWdaParams);
14980 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14981
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14982 return;
14983}
14984
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14985#ifdef WLAN_FEATURE_PACKET_FILTERING
14986/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14987 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14988 *
14989 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14990void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]14991 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
14992 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14993{
14994 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14996 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14997 if(NULL == pWdaParams)
14998 {
14999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15000 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15001 VOS_ASSERT(0) ;
15002 return ;
15003 }
15004
15005 vos_mem_free(pWdaParams->wdaMsgParam) ;
15006 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15007 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15008 //print a msg, nothing else to do
15009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15010 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15011 return ;
15012}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15013/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15014 * FUNCTION: WDA_8023MulticastListReqCallback
15015 * Free memory.
15016 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15017 */
15018void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15019{
15020 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15021
15022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15023 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15024
15025 if(NULL == pWdaParams)
15026 {
15027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15028 "%s: pWdaParams received NULL", __func__);
15029 VOS_ASSERT(0);
15030 return;
15031 }
15032
15033 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15034 {
15035 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15036 vos_mem_free(pWdaParams->wdaMsgParam);
15037 vos_mem_free(pWdaParams);
15038 }
15039
15040 return;
15041}
15042/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15043 * FUNCTION: WDA_Process8023MulticastListReq
15044 * Request to WDI to add 8023 Multicast List
15045 */
15046VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15047 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15048{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15049 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15050 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15051 tWDA_ReqParams *pWdaParams ;
15052 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15054 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15055 pwdiFltPktSetMcListReqParamsType =
15056 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15057 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15058 ) ;
15059 if(NULL == pwdiFltPktSetMcListReqParamsType)
15060 {
15061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15062 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15063 return VOS_STATUS_E_NOMEM;
15064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15065 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15066 if(NULL == pWdaParams)
15067 {
15068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15069 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15070 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15071 return VOS_STATUS_E_NOMEM;
15072 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15073
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15074 //
15075 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15076 //
15077 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15078 pRcvFltMcAddrList->ulMulticastAddrCnt;
15079
15080 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15081 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15082 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15083 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15084
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15085 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15086 {
15087 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15088 &(pRcvFltMcAddrList->multicastAddr[i]),
15089 sizeof(tSirMacAddr));
15090 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15091 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15092 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15093
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15094 /* Store Params pass it to WDI */
15095 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15096 pWdaParams->pWdaContext = pWDA;
15097 /* Store param pointer as passed in by caller */
15098 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15099 status = WDI_8023MulticastListReq(
15100 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15101 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15102 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15103 if(IS_WDI_STATUS_FAILURE(status))
15104 {
15105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15106 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15107 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15108 vos_mem_free(pWdaParams->wdaMsgParam);
15109 vos_mem_free(pWdaParams);
15110 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15111 return CONVERT_WDI2VOS_STATUS(status) ;
15112}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15113/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15114 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15115 *
15116 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15117void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15118 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15119 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15120{
15121 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15123 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15124 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15125 if(NULL == pWdaParams)
15126 {
15127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15128 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15129 VOS_ASSERT(0) ;
15130 return ;
15131 }
15132
15133 vos_mem_free(pWdaParams->wdaMsgParam) ;
15134 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15135 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15136 //print a msg, nothing else to do
15137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15138 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15139 return ;
15140}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15141
15142/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15143 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15144 * Free memory.
15145 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15146 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15147void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15148 void* pUserData)
15149{
15150 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15151
15152 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15153 "<------ %s, wdiStatus: %d",
15154 __func__, wdiStatus);
15155
15156 if (NULL == pWdaParams)
15157 {
15158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15159 "%s: Invalid pWdaParams pointer", __func__);
15160 VOS_ASSERT(0);
15161 return;
15162 }
15163
15164 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15165 {
15166 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15167 vos_mem_free(pWdaParams->wdaMsgParam);
15168 vos_mem_free(pWdaParams);
15169 }
15170
15171 return;
15172}
15173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15174/*
15175 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15176 * Request to WDI to set Receive Filters
15177 */
15178VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15179 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15180{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15181 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15182 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15183 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15184 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15185 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15186 tWDA_ReqParams *pWdaParams ;
15187 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15188 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15189 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15190 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15191 {
15192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15193 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15194 VOS_ASSERT(0);
15195 return VOS_STATUS_E_NOMEM;
15196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15197 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15198 if(NULL == pWdaParams)
15199 {
15200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15201 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15202 VOS_ASSERT(0);
15203 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15204 return VOS_STATUS_E_NOMEM;
15205 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15206 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15207 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15208 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15209 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15210 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15211 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15212
15213 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15214 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15215
15216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15217 "FID %d FT %d NParams %d CT %d",
15218 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15219 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15220 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15221 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15222 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15223 {
15224 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15225 &pRcvPktFilterCfg->paramsData[i],
15226 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15228 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15229 pwdiSetRcvPktFilterReqParamsType->
15230 wdiPktFilterCfg.paramsData[i].protocolLayer,
15231 pwdiSetRcvPktFilterReqParamsType->
15232 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15234 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15235 pwdiSetRcvPktFilterReqParamsType->
15236 wdiPktFilterCfg.paramsData[i].dataOffset,
15237 pwdiSetRcvPktFilterReqParamsType->
15238 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15240 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15241 pwdiSetRcvPktFilterReqParamsType->
15242 wdiPktFilterCfg.paramsData[i].compareData[0],
15243 pwdiSetRcvPktFilterReqParamsType->
15244 wdiPktFilterCfg.paramsData[i].compareData[1],
15245 pwdiSetRcvPktFilterReqParamsType->
15246 wdiPktFilterCfg.paramsData[i].compareData[2],
15247 pwdiSetRcvPktFilterReqParamsType->
15248 wdiPktFilterCfg.paramsData[i].compareData[3],
15249 pwdiSetRcvPktFilterReqParamsType->
15250 wdiPktFilterCfg.paramsData[i].compareData[4],
15251 pwdiSetRcvPktFilterReqParamsType->
15252 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15254 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15255 pwdiSetRcvPktFilterReqParamsType->
15256 wdiPktFilterCfg.paramsData[i].dataMask[0],
15257 pwdiSetRcvPktFilterReqParamsType->
15258 wdiPktFilterCfg.paramsData[i].dataMask[1],
15259 pwdiSetRcvPktFilterReqParamsType->
15260 wdiPktFilterCfg.paramsData[i].dataMask[2],
15261 pwdiSetRcvPktFilterReqParamsType->
15262 wdiPktFilterCfg.paramsData[i].dataMask[3],
15263 pwdiSetRcvPktFilterReqParamsType->
15264 wdiPktFilterCfg.paramsData[i].dataMask[4],
15265 pwdiSetRcvPktFilterReqParamsType->
15266 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15267 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15268 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15269 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15270 /* Store Params pass it to WDI */
15271 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15272 pWdaParams->pWdaContext = pWDA;
15273 /* Store param pointer as passed in by caller */
15274 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15275 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15276 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15277 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15278 if(IS_WDI_STATUS_FAILURE(status))
15279 {
15280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15281 "Failure in SetFilter(),free all the memory,status %d ",status);
15282 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15283 vos_mem_free(pWdaParams->wdaMsgParam);
15284 vos_mem_free(pWdaParams);
15285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15286 return CONVERT_WDI2VOS_STATUS(status) ;
15287}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15288/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15289 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15290 *
15291 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15292void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15293 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15294 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15295{
15296 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15297 tWDA_CbContext *pWDA;
15298 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15299 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15300 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15301 tANI_U8 i;
15302 vos_msg_t vosMsg;
15303
15304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15305 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15306 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15307
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15308 if(NULL == pRcvFltPktMatchCntRsp)
15309 {
15310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15311 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15312 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15313 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15314 return ;
15315 }
15316
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15317 if(NULL == pWdaParams)
15318 {
15319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15320 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15321 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15322 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15323 return ;
15324 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15325 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15326 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15327 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15328 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15329
15330 /* Message Header */
15331 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15332 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15333
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15334 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15335
15336 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15337 {
15338 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15339 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15340 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15341 /* VOS message wrapper */
15342 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15343 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15344 vosMsg.bodyval = 0;
15345 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15346 {
15347 /* free the mem and return */
15348 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15349 }
15350
15351 vos_mem_free(pWdaParams->wdaMsgParam) ;
15352 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15353 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15354
15355 return;
15356}
15357/*
15358 * FUNCTION: WDA_FilterMatchCountReqCallback
15359 * Free memory and send RSP back to SME.
15360 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15361 */
15362void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15363{
15364 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15365 vos_msg_t vosMsg;
15366
15367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15368 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15369
15370 if(NULL == pWdaParams)
15371 {
15372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15373 "%s: pWdaParams received NULL", __func__);
15374 VOS_ASSERT(0);
15375 return;
15376 }
15377
15378 /* VOS message wrapper */
15379 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15380 vosMsg.bodyptr = NULL;
15381 vosMsg.bodyval = 0;
15382
15383 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15384 {
15385 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15386 vos_mem_free(pWdaParams->wdaMsgParam);
15387 vos_mem_free(pWdaParams);
15388 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15389 }
15390
15391 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15392}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15393/*
15394 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15395 * Request to WDI to get PC Filter Match Count
15396 */
15397VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15398{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15399 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15400 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15401 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15402 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15404 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15405 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15406 {
15407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15408 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15409 VOS_ASSERT(0);
15410 return VOS_STATUS_E_NOMEM;
15411 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15412 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15413 if(NULL == pWdaParams)
15414 {
15415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15416 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15417 VOS_ASSERT(0);
15418 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15419 return VOS_STATUS_E_NOMEM;
15420 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15421
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15422 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15423 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15424
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15425 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15426 pRcvFltPktMatchRsp->bssId,
15427 sizeof(wpt_macAddr));
15428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15429 /* Store Params pass it to WDI */
15430 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15431 pWdaParams->pWdaContext = pWDA;
15432 /* Store param pointer as passed in by caller */
15433 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15434 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15435 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15436 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15437 if(IS_WDI_STATUS_FAILURE(status))
15438 {
15439 /* failure returned by WDI API */
15440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15441 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15442 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15443 vos_mem_free(pWdaParams) ;
15444 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15445 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15446 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15447 return CONVERT_WDI2VOS_STATUS(status) ;
15448}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15449/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15450 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15451 *
15452 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15453void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15454 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15455 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15456{
15457 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15459 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15460/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15461 if(NULL == pWdaParams)
15462 {
15463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15464 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15465 VOS_ASSERT(0) ;
15466 return ;
15467 }
15468
15469 vos_mem_free(pWdaParams->wdaMsgParam) ;
15470 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15471 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15472 //print a msg, nothing else to do
15473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15474 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15475 return ;
15476}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15477/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15478 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15479 * Free memory.
15480 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15481 */
15482void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15483{
15484 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15485
15486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15487 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15488
15489 if(NULL == pWdaParams)
15490 {
15491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15492 "%s: Invalid pWdaParams pointer", __func__);
15493 VOS_ASSERT(0);
15494 return;
15495 }
15496
15497 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15498 {
15499 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15500 vos_mem_free(pWdaParams->wdaMsgParam);
15501 vos_mem_free(pWdaParams);
15502 }
15503
15504 return;
15505}
15506/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15507 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15508 * Request to WDI to clear Receive Filters
15509 */
15510VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15511 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15512{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15513 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15514 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15515 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15516 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15518 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15519 if(NULL == pwdiRcvFltPktClearReqParamsType)
15520 {
15521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15522 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15523 VOS_ASSERT(0);
15524 return VOS_STATUS_E_NOMEM;
15525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15526 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15527 if(NULL == pWdaParams)
15528 {
15529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15530 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15531 VOS_ASSERT(0);
15532 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15533 return VOS_STATUS_E_NOMEM;
15534 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15535 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
15536 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15537 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
15538 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
15539 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
15540 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15541
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15542 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15543 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15544 /* Store Params pass it to WDI */
15545 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
15546 pWdaParams->pWdaContext = pWDA;
15547 /* Store param pointer as passed in by caller */
15548 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15549 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15550 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15551 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15552 if(IS_WDI_STATUS_FAILURE(status))
15553 {
15554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15555 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
15556 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]15557 vos_mem_free(pWdaParams->wdaMsgParam);
15558 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15560 return CONVERT_WDI2VOS_STATUS(status) ;
15561}
15562#endif // WLAN_FEATURE_PACKET_FILTERING
15563
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15564/*
15565 * FUNCTION: WDA_ProcessSetPowerParamsReq
15566 * Request to WDI to set power params
15567 */
15568VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
15569 tSirSetPowerParamsReq *pPowerParams)
15570{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15571 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15572 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
15573 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15574 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15576 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15577 if(NULL == pwdiSetPowerParamsReqInfo)
15578 {
15579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15580 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15581 VOS_ASSERT(0);
15582 return VOS_STATUS_E_NOMEM;
15583 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15584 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15585 if(NULL == pWdaParams)
15586 {
15587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15588 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15589 VOS_ASSERT(0);
15590 vos_mem_free(pwdiSetPowerParamsReqInfo);
15591 return VOS_STATUS_E_NOMEM;
15592 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15593
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15594
15595 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
15596 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15597 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
15598 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15599 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
15600 pPowerParams->uListenInterval;
15601 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
15602 pPowerParams->uBcastMcastFilter;
15603 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
15604 pPowerParams->uEnableBET;
15605 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
15606 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]15607 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
15608 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15609 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
15610 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15612 /* Store Params pass it to WDI */
15613 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
15614 pWdaParams->pWdaContext = pWDA;
15615 /* Store param pointer as passed in by caller */
15616 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15617 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15618 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15619 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15620 if(IS_WDI_STATUS_FAILURE(status))
15621 {
15622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15623 "Failure in Set power params REQ WDI API, free all the memory " );
15624 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15625 vos_mem_free(pWdaParams->wdaMsgParam);
15626 pWdaParams->wdaWdiApiMsgParam = NULL;
15627 pWdaParams->wdaMsgParam = NULL;
15628 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15629 return CONVERT_WDI2VOS_STATUS(status) ;
15630}
15631
15632/*
15633 * FUNCTION: WDA_SetTmLevelRspCallback
15634 * Set TM Level response
15635 */
15636void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
15637{
15638 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15639
15640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15641 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15642
15643 if(NULL == pWdaParams)
15644 {
15645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15646 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15647 VOS_ASSERT(0) ;
15648 return ;
15649 }
15650
15651 /* Dose not need to send notification to upper layer
15652 * Just free allocated resources */
15653 if( pWdaParams != NULL )
15654 {
15655 if( pWdaParams->wdaWdiApiMsgParam != NULL )
15656 {
15657 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15658 }
15659 vos_mem_free(pWdaParams->wdaMsgParam) ;
15660 vos_mem_free(pWdaParams) ;
15661 }
15662}
15663
15664/*
15665 * FUNCTION: WDA_ProcessSetTmLevelReq
15666 * Set TM Level request
15667 */
15668VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
15669 tAniSetTmLevelReq *setTmLevelReq)
15670{
15671 WDI_Status status = WDI_STATUS_SUCCESS ;
15672 tWDA_ReqParams *pWdaParams ;
15673 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
15674 (WDI_SetTmLevelReqType *)vos_mem_malloc(
15675 sizeof(WDI_SetTmLevelReqType)) ;
15676 if(NULL == wdiSetTmLevelReq)
15677 {
15678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15679 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15680 VOS_ASSERT(0);
15681 return VOS_STATUS_E_NOMEM;
15682 }
15683
15684 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15685 if(NULL == pWdaParams)
15686 {
15687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15688 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15689 VOS_ASSERT(0);
15690 vos_mem_free(wdiSetTmLevelReq);
15691 return VOS_STATUS_E_NOMEM;
15692 }
15693
15694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15695 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15696
15697 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
15698 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
15699
15700 pWdaParams->pWdaContext = pWDA;
15701 pWdaParams->wdaMsgParam = setTmLevelReq;
15702 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
15703
15704 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
15705 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
15706
15707 if(IS_WDI_STATUS_FAILURE(status))
15708 {
15709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]15710 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15711 vos_mem_free(pWdaParams->wdaMsgParam) ;
15712 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15713 vos_mem_free(pWdaParams) ;
15714 }
15715
15716 return CONVERT_WDI2VOS_STATUS(status) ;
15717}
15718
15719VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
15720 tpTxControlParams pTxCtrlParam)
15721{
15722 VOS_STATUS wdaStatus;
15723
15724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15725 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15726 if( pTxCtrlParam == NULL )
15727 {
15728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15729 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15730 return VOS_STATUS_E_FAILURE;
15731 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15732 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
15733 {
15734 wdaStatus = WDA_SuspendDataTx(pWDA);
15735 }
15736 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
15737 {
15738 wdaStatus = WDA_ResumeDataTx(pWDA);
15739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15740 return wdaStatus;
15741}
15742
15743 /* FUNCTION WDA_featureCapsExchange
15744 * WDA API to invoke capability exchange between host and FW.
15745 */
15746void WDA_featureCapsExchange(v_PVOID_t pVosContext)
15747{
15748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15749 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15750 WDI_featureCapsExchangeReq( NULL, pVosContext);
15751}
15752
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]15753/* FUNCTION WDA_disableCapablityFeature
15754 * WDA API to diable Active mode offload in host.
15755 */
15756void WDA_disableCapablityFeature(tANI_U8 feature_index)
15757{
15758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15759 "%s:enter", __func__ );
15760 WDI_disableCapablityFeature(feature_index);
15761}
15762
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15763 /* FUNCTION WDA_getHostWlanFeatCaps
15764 * Wrapper for WDI API, that will return if the feature (enum value).passed
15765 * to this API is supported or not in Host
15766 * return value
15767 * 0 - implies feature is NOT Supported
15768 * any non zero value - implies feature is SUPPORTED
15769 */
15770tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
15771{
15772 return WDI_getHostWlanFeatCaps(featEnumValue);
15773}
15774
15775 /* FUNCTION WDA_getFwWlanFeatCaps
15776 * Wrapper for WDI API, that will return if the feature (enum value).passed
15777 * to this API is supported or not in FW
15778 * return value
15779 * 0 - implies feature is NOT Supported
15780 * any non zero value - implies feature is SUPPORTED
15781 */
15782tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
15783{
15784 return WDI_getFwWlanFeatCaps(featEnumValue);
15785}
15786
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]15787
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15788/*
15789 * FUNCTION: WDA_shutdown
15790 * Shutdown WDA/WDI without handshaking with Riva.
15791 * Synchronous function.
15792 */
15793VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
15794{
15795 WDI_Status wdiStatus;
15796 //tANI_U8 eventIdx = 0;
15797 VOS_STATUS status = VOS_STATUS_SUCCESS;
15798 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15799 if (NULL == pWDA)
15800 {
15801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15802 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15803 VOS_ASSERT(0);
15804 return VOS_STATUS_E_FAILURE;
15805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15806 /* FTM mode stay START_STATE */
15807 if( (WDA_READY_STATE != pWDA->wdaState) &&
15808 (WDA_INIT_STATE != pWDA->wdaState) &&
15809 (WDA_START_STATE != pWDA->wdaState) )
15810 {
15811 VOS_ASSERT(0);
15812 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15813
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15814 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
15815 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15816 {
15817 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15818 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15819 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]15820 else
15821 {
15822 vos_event_destroy(&pWDA->ftmStopDoneEvent);
15823 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15824
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15825 /* call WDI shutdown */
15826 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15827 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
15828 {
15829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15830 "error in WDA Stop" );
15831 status = VOS_STATUS_E_FAILURE;
15832 }
15833 /* WDI stop is synchrnous, shutdown is complete when it returns */
15834 pWDA->wdaState = WDA_STOP_STATE;
15835
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15836 /* shutdown should perform the stop & close actions. */
15837 /* Destroy the event */
15838 status = vos_event_destroy(&pWDA->txFrameEvent);
15839 if(!VOS_IS_STATUS_SUCCESS(status))
15840 {
15841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15842 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15843 status = VOS_STATUS_E_FAILURE;
15844 }
15845 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
15846 if(!VOS_IS_STATUS_SUCCESS(status))
15847 {
15848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15849 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15850 status = VOS_STATUS_E_FAILURE;
15851 }
15852 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
15853 if(!VOS_IS_STATUS_SUCCESS(status))
15854 {
15855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15856 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15857 status = VOS_STATUS_E_FAILURE;
15858 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15859 /* free WDA context */
15860 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
15861 if ( !VOS_IS_STATUS_SUCCESS(status) )
15862 {
15863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15864 "error in WDA close " );
15865 status = VOS_STATUS_E_FAILURE;
15866 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15867 return status;
15868}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15869
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15870/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15871 * FUNCTION: WDA_setNeedShutdown
15872 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15873 */
15874
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15875void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15876{
15877 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15878 if(pWDA == NULL)
15879 {
15880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15881 "Could not get the WDA Context pointer" );
15882 return;
15883 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15884 pWDA->needShutdown = TRUE;
15885}
15886/*
15887 * FUNCTION: WDA_needShutdown
15888 * WDA needs a shutdown
15889 */
15890
15891v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
15892{
15893 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15894 if(pWDA == NULL)
15895 {
15896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15897 "Could not get the WDA Context pointer" );
15898 return 0;
15899 }
15900 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15901}
15902
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15903#ifdef WLAN_FEATURE_11AC
15904/*
15905 * FUNCTION: WDA_SetBeaconFilterReqCallback
15906 *
15907 */
15908void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
15909{
15910 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15912 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15913 if(NULL == pWdaParams)
15914 {
15915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15916 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15917 VOS_ASSERT(0) ;
15918 return ;
15919 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15920
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15921 vos_mem_free(pWdaParams->wdaMsgParam) ;
15922 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15923 vos_mem_free(pWdaParams) ;
15924 /*
15925 * No respone required for SetBeaconFilter req so just free the request
15926 * param here
15927 */
15928
15929 return ;
15930}
15931
15932VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
15933 tUpdateVHTOpMode *pData)
15934{
15935 WDI_Status status = WDI_STATUS_SUCCESS ;
15936 tWDA_ReqParams *pWdaParams ;
15937 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
15938 sizeof(WDI_UpdateVHTOpMode)) ;
15939 if(NULL == wdiTemp)
15940 {
15941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15942 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15943 VOS_ASSERT(0);
15944 return VOS_STATUS_E_NOMEM;
15945 }
15946 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15947 if(NULL == pWdaParams)
15948 {
15949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15950 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15951 VOS_ASSERT(0);
15952 vos_mem_free(wdiTemp);
15953 return VOS_STATUS_E_NOMEM;
15954 }
15955
15956 wdiTemp->opMode = pData->opMode;
15957 wdiTemp->staId = pData->staId;
15958
15959 pWdaParams->pWdaContext = pWDA;
15960 /* Store Req pointer, as this will be used for response */
15961 pWdaParams->wdaMsgParam = (void *)pData;
15962 /* store Params pass it to WDI */
15963 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
15964
15965 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
15966
15967 if(IS_WDI_STATUS_FAILURE(status))
15968 {
15969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15970 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
15971 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15972 vos_mem_free(pWdaParams->wdaMsgParam);
15973 vos_mem_free(pWdaParams);
15974 }
15975 return CONVERT_WDI2VOS_STATUS(status) ;
15976}
15977#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]15978
15979/*==========================================================================
15980 FUNCTION WDA_TransportChannelDebug
15981
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]15982 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]15983 Display Transport Channel debugging information
15984 User may request to display DXE channel snapshot
15985 Or if host driver detects any abnormal stcuk may display
15986
15987 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]15988 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]15989 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]15990 debugFlags : Enable stall detect features
15991 defined by WPAL_DeviceDebugFlags
15992 These features may effect
15993 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]15994
15995 RETURN VALUE
15996 NONE
15997
15998===========================================================================*/
15999void WDA_TransportChannelDebug
16000(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16001 tpAniSirGlobal pMac,
16002 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16003 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16004)
16005{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16006 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16007 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16008}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16009
16010/*==========================================================================
16011 FUNCTION WDA_SetEnableSSR
16012
16013 DESCRIPTION
16014 API to enable/disable SSR on WDI timeout
16015
16016 PARAMETERS
16017 enableSSR : enable/disable SSR
16018
16019 RETURN VALUE
16020 NONE
16021
16022===========================================================================*/
16023void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16024{
16025 WDI_SetEnableSSR(enableSSR);
16026}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16027
16028#ifdef FEATURE_WLAN_LPHB
16029/*
16030 * FUNCTION: WDA_LPHBconfRspCallback
16031 *
16032 */
16033void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16034{
16035 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16036
16037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16038 "<------ %s " ,__func__);
16039 if (NULL == pWdaParams)
16040 {
16041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16042 "%s: pWdaParams received NULL", __func__);
16043 VOS_ASSERT(0) ;
16044 return ;
16045 }
16046
16047 /* Do not need to send notification to upper layer
16048 * Just free allocated resources */
16049 if (pWdaParams != NULL)
16050 {
16051 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16052 {
16053 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16054 }
16055 vos_mem_free(pWdaParams->wdaMsgParam) ;
16056 vos_mem_free(pWdaParams) ;
16057 }
16058
16059 return;
16060}
16061
16062/*
16063 * FUNCTION: WDA_ProcessLPHBConfReq
16064 *
16065 */
16066VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16067 tSirLPHBReq *pData)
16068{
16069 WDI_Status wdiStatus;
16070 tWDA_ReqParams *pWdaParams ;
16071
16072 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16073 "------> %s " , __func__);
16074
16075 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16076 if (NULL == pWdaParams)
16077 {
16078 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16079 "%s: VOS MEM Alloc Failure", __func__);
16080 VOS_ASSERT(0);
16081 vos_mem_free(pData);
16082 return VOS_STATUS_E_NOMEM;
16083 }
16084
16085 pWdaParams->pWdaContext = pWDA;
16086 pWdaParams->wdaMsgParam = (void *)pData;
16087 pWdaParams->wdaWdiApiMsgParam = NULL;
16088
16089 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16090 if (WDI_STATUS_PENDING == wdiStatus)
16091 {
16092 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16093 "Pending received for %s:%d ", __func__, __LINE__);
16094 }
16095 else if (WDI_STATUS_SUCCESS != wdiStatus)
16096 {
16097 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16098 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16099 vos_mem_free(pWdaParams->wdaMsgParam);
16100 vos_mem_free(pWdaParams);
16101 }
16102
16103 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16104}
16105#endif /* FEATURE_WLAN_LPHB */
16106
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16107void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16108 void* pUserData)
16109{
16110 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16111
16112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16113 "<------ %s " ,__func__);
16114 if (NULL == pBcnMissRateInfo)
16115 {
16116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16117 "%s: pWdaParams received NULL", __func__);
16118 VOS_ASSERT(0) ;
16119 return ;
16120 }
16121 if (pBcnMissRateInfo->callback)
16122 {
16123 pBcnMissRateInfo->callback(status, bcnMissRate,
16124 pBcnMissRateInfo->data);
16125 }
16126 vos_mem_free(pUserData);
16127
16128 return;
16129}
16130
16131v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16132 tSirBcnMissRateReq *pData)
16133{
16134 WDI_Status wdiStatus;
16135 tSirBcnMissRateInfo *pBcnMissRateInfo;
16136
16137 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16138 "------> %s " , __func__);
16139
16140 pBcnMissRateInfo =
16141 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16142 if (NULL == pBcnMissRateInfo)
16143 {
16144 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16145 "%s: VOS MEM Alloc Failure", __func__);
16146 VOS_ASSERT(0);
16147 vos_mem_free(pData);
16148 return;
16149 }
16150
16151 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16152 pBcnMissRateInfo->data = pData->data;
16153
16154 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16155 WDA_GetBcnMissRateCallback,
16156 pData->bssid);
16157 if (WDI_STATUS_PENDING == wdiStatus)
16158 {
16159 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16160 "Pending received for %s:%d ", __func__, __LINE__);
16161 }
16162 else if (WDI_STATUS_SUCCESS != wdiStatus)
16163 {
16164 if (pBcnMissRateInfo->callback)
16165 {
16166 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16167 -1, pBcnMissRateInfo->data);
16168 }
16169 }
16170 vos_mem_free(pData);
16171}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16172
16173#ifdef WLAN_FEATURE_EXTSCAN
16174
16175/*==========================================================================
16176 FUNCTION WDA_EXTScanStartRspCallback
16177
16178 DESCRIPTION
16179 API to send EXTScan Start Response to HDD
16180
16181 PARAMETERS
16182 pEventData: Response from FW
16183 pUserData:
16184===========================================================================*/
16185void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16186{
16187 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16188 tWDA_CbContext *pWDA = NULL;
16189 void *pCallbackContext;
16190 tpAniSirGlobal pMac;
16191
16192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16193 "%s:", __func__);
16194 if (NULL == pWdaParams)
16195 {
16196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16197 "%s: pWdaParams received NULL", __func__);
16198 VOS_ASSERT(0);
16199 return;
16200 }
16201
16202 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16203
16204 if (NULL == pWDA)
16205 {
16206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16207 "%s: pWDA received NULL", __func__);
16208 VOS_ASSERT(0);
16209 goto error;
16210 }
16211
16212 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16213 if (NULL == pMac)
16214 {
16215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16216 "%s:pMac is NULL", __func__);
16217 VOS_ASSERT(0);
16218 goto error;
16219 }
16220
16221 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16222
16223 if (pMac->sme.pEXTScanIndCb)
16224 {
16225 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16226 pEventData);
16227 }
16228 else
16229 {
16230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16231 "%s:HDD callback is null", __func__);
16232 VOS_ASSERT(0);
16233 }
16234
16235error:
16236
16237 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16238 {
16239 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16240 }
16241 if (pWdaParams->wdaMsgParam != NULL)
16242 {
16243 vos_mem_free(pWdaParams->wdaMsgParam);
16244 }
16245 vos_mem_free(pWdaParams) ;
16246
16247 return;
16248}
16249
16250/*==========================================================================
16251 FUNCTION WDA_EXTScanStopRspCallback
16252
16253 DESCRIPTION
16254 API to send EXTScan Stop Response to HDD
16255
16256 PARAMETERS
16257 pEventData: Response from FW
16258 pUserData:
16259===========================================================================*/
16260void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16261{
16262 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16263 tWDA_CbContext *pWDA = NULL;
16264 void *pCallbackContext;
16265 tpAniSirGlobal pMac;
16266
16267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16268 "%s:", __func__);
16269 if (NULL == pWdaParams)
16270 {
16271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16272 "%s: pWdaParams received NULL", __func__);
16273 VOS_ASSERT(0);
16274 return;
16275 }
16276
16277 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16278
16279 if (NULL == pWDA)
16280 {
16281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16282 "%s: pWDA received NULL", __func__);
16283 VOS_ASSERT(0);
16284 goto error;
16285 }
16286
16287 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16288 if (NULL == pMac)
16289 {
16290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16291 "%s:pMac is NULL", __func__);
16292 VOS_ASSERT(0);
16293 goto error;
16294 }
16295 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16296
16297 if (pMac->sme.pEXTScanIndCb)
16298 {
16299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16300 "%s:HDD call back function called", __func__);
16301 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16302 pEventData);
16303 }
16304 else
16305 {
16306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16307 "%s:HDD callback is null", __func__);
16308 VOS_ASSERT(0);
16309 }
16310
16311error:
16312
16313 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16314 {
16315 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16316 }
16317 if (pWdaParams->wdaMsgParam != NULL)
16318 {
16319 vos_mem_free(pWdaParams->wdaMsgParam);
16320 }
16321 vos_mem_free(pWdaParams) ;
16322
16323
16324 return;
16325}
16326
16327/*==========================================================================
16328 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16329
16330 DESCRIPTION
16331 API to send EXTScan Get Cached Results Response to HDD
16332
16333 PARAMETERS
16334 pEventData: Response from FW
16335 pUserData:
16336===========================================================================*/
16337void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16338{
16339 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16340 tWDA_CbContext *pWDA = NULL;
16341 void *pCallbackContext;
16342 tpAniSirGlobal pMac;
16343
16344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16345 "%s: ", __func__);
16346 if (NULL == pWdaParams)
16347 {
16348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16349 "%s: pWdaParams received NULL", __func__);
16350 VOS_ASSERT(0);
16351 return;
16352 }
16353
16354 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16355
16356 if (NULL == pWDA)
16357 {
16358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16359 "%s: pWDA received NULL", __func__);
16360 VOS_ASSERT(0);
16361 goto error;
16362 }
16363
16364 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16365 if (NULL == pMac)
16366 {
16367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16368 "%s:pMac is NULL", __func__);
16369 VOS_ASSERT(0);
16370 goto error;
16371 }
16372
16373 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16374
16375 if (pMac->sme.pEXTScanIndCb)
16376 {
16377 pMac->sme.pEXTScanIndCb(pCallbackContext,
16378 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16379 pEventData);
16380 }
16381 else
16382 {
16383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16384 "%s:HDD callback is null", __func__);
16385 VOS_ASSERT(0);
16386 }
16387
16388
16389error:
16390
16391 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16392 {
16393 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16394 }
16395 if (pWdaParams->wdaMsgParam != NULL)
16396 {
16397 vos_mem_free(pWdaParams->wdaMsgParam);
16398 }
16399 vos_mem_free(pWdaParams) ;
16400
16401 return;
16402}
16403
16404/*==========================================================================
16405 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16406
16407 DESCRIPTION
16408 API to send EXTScan Get Capabilities Response to HDD
16409
16410 PARAMETERS
16411 pEventData: Response from FW
16412 pUserData:
16413===========================================================================*/
16414void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16415{
16416 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16417 tWDA_CbContext *pWDA = NULL;
16418 void *pCallbackContext;
16419 tpAniSirGlobal pMac;
16420
16421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16422 "%s:", __func__);
16423 if (NULL == pWdaParams)
16424 {
16425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16426 "%s: pWdaParams received NULL", __func__);
16427 VOS_ASSERT(0);
16428 return;
16429 }
16430
16431 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16432
16433 if (NULL == pWDA)
16434 {
16435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16436 "%s: pWDA received NULL", __func__);
16437 VOS_ASSERT(0);
16438 goto error;
16439 }
16440
16441 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16442 if (NULL == pMac)
16443 {
16444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16445 "%s:pMac is NULL", __func__);
16446 VOS_ASSERT(0);
16447 goto error;
16448 }
16449
16450 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16451
16452 if (pMac->sme.pEXTScanIndCb)
16453 {
16454 pMac->sme.pEXTScanIndCb(pCallbackContext,
16455 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16456 pEventData);
16457 }
16458 else
16459 {
16460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16461 "%s:HDD callback is null", __func__);
16462 VOS_ASSERT(0);
16463 }
16464
16465
16466error:
16467
16468 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16469 {
16470 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16471 }
16472 if (pWdaParams->wdaMsgParam != NULL)
16473 {
16474 vos_mem_free(pWdaParams->wdaMsgParam);
16475 }
16476 vos_mem_free(pWdaParams) ;
16477
16478 return;
16479}
16480
16481/*==========================================================================
16482 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16483
16484 DESCRIPTION
16485 API to send EXTScan Set BSSID Hotlist Response to HDD
16486
16487 PARAMETERS
16488 pEventData: Response from FW
16489 pUserData:
16490===========================================================================*/
16491void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16492{
16493 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16494 tWDA_CbContext *pWDA = NULL;
16495 void *pCallbackContext;
16496 tpAniSirGlobal pMac;
16497
16498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16499 "%s: ", __func__);
16500 if (NULL == pWdaParams)
16501 {
16502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16503 "%s: pWdaParams received NULL", __func__);
16504 VOS_ASSERT(0) ;
16505 return;
16506 }
16507
16508 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16509
16510 if (NULL == pWDA)
16511 {
16512 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16513 "%s: pWDA received NULL", __func__);
16514 VOS_ASSERT(0);
16515 goto error;
16516 }
16517
16518 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16519 if (NULL == pMac)
16520 {
16521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16522 "%s:pMac is NULL", __func__);
16523 VOS_ASSERT(0);
16524 goto error;
16525 }
16526
16527 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16528
16529 if (pMac->sme.pEXTScanIndCb)
16530 {
16531 pMac->sme.pEXTScanIndCb(pCallbackContext,
16532 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16533 pEventData);
16534 }
16535 else
16536 {
16537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16538 "%s:HDD callback is null", __func__);
16539 VOS_ASSERT(0);
16540 }
16541
16542
16543error:
16544
16545 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16546 {
16547 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16548 }
16549 if (pWdaParams->wdaMsgParam != NULL)
16550 {
16551 vos_mem_free(pWdaParams->wdaMsgParam);
16552 }
16553 vos_mem_free(pWdaParams) ;
16554
16555 return;
16556}
16557
16558/*==========================================================================
16559 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
16560
16561 DESCRIPTION
16562 API to send EXTScan ReSet BSSID Hotlist Response to HDD
16563
16564 PARAMETERS
16565 pEventData: Response from FW
16566 pUserData:
16567===========================================================================*/
16568void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16569{
16570 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16571 tWDA_CbContext *pWDA = NULL;
16572 void *pCallbackContext;
16573 tpAniSirGlobal pMac;
16574
16575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16576 "%s:", __func__);
16577 if (NULL == pWdaParams)
16578 {
16579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16580 "%s: pWdaParams received NULL", __func__);
16581 VOS_ASSERT(0) ;
16582 return;
16583 }
16584
16585 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16586
16587 if (NULL == pWDA)
16588 {
16589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16590 "%s: pWDA received NULL", __func__);
16591 VOS_ASSERT(0);
16592 goto error;
16593 }
16594
16595 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16596 if (NULL == pMac)
16597 {
16598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16599 "%s:pMac is NULL", __func__);
16600 VOS_ASSERT(0);
16601 goto error;
16602 }
16603
16604 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16605
16606 if (pMac->sme.pEXTScanIndCb)
16607 {
16608 pMac->sme.pEXTScanIndCb(pCallbackContext,
16609 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
16610 pEventData);
16611 }
16612 else
16613 {
16614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16615 "%s:HDD callback is null", __func__);
16616 VOS_ASSERT(0);
16617 }
16618
16619
16620error:
16621
16622 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16623 {
16624 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16625 }
16626 if (pWdaParams->wdaMsgParam != NULL)
16627 {
16628 vos_mem_free(pWdaParams->wdaMsgParam);
16629 }
16630 vos_mem_free(pWdaParams) ;
16631
16632 return;
16633}
16634
16635/*==========================================================================
16636 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
16637
16638 DESCRIPTION
16639 API to send EXTScan Set Significant RSSI Change RSP to HDD
16640
16641 PARAMETERS
16642 pEventData: Response from FW
16643 pUserData:
16644===========================================================================*/
16645void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
16646{
16647 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16648 tWDA_CbContext *pWDA = NULL;
16649 void *pCallbackContext;
16650 tpAniSirGlobal pMac;
16651
16652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16653 "%s:", __func__);
16654 if (NULL == pWdaParams)
16655 {
16656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16657 "%s: pWdaParams received NULL", __func__);
16658 VOS_ASSERT(0) ;
16659 return;
16660 }
16661
16662 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16663
16664 if (NULL == pWDA)
16665 {
16666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16667 "%s: pWDA received NULL", __func__);
16668 VOS_ASSERT(0);
16669 goto error;
16670 }
16671
16672 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16673 if (NULL == pMac)
16674 {
16675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16676 "%s:pMac is NULL", __func__);
16677 VOS_ASSERT(0);
16678 goto error;
16679 }
16680
16681 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16682
16683 if (pMac->sme.pEXTScanIndCb)
16684 {
16685 pMac->sme.pEXTScanIndCb(pCallbackContext,
16686 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
16687 pEventData);
16688 }
16689 else
16690 {
16691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16692 "%s:HDD callback is null", __func__);
16693 VOS_ASSERT(0);
16694 }
16695
16696
16697error:
16698
16699 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16700 {
16701 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16702 }
16703 if (pWdaParams->wdaMsgParam != NULL)
16704 {
16705 vos_mem_free(pWdaParams->wdaMsgParam);
16706 }
16707 vos_mem_free(pWdaParams) ;
16708
16709 return;
16710}
16711
16712/*==========================================================================
16713 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
16714
16715 DESCRIPTION
16716 API to send EXTScan Set Significant RSSI Change RSP to HDD
16717
16718 PARAMETERS
16719 pEventData: Response from FW
16720 pUserData:
16721===========================================================================*/
16722void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
16723 void* pUserData)
16724{
16725 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16726 tWDA_CbContext *pWDA = NULL;
16727 void *pCallbackContext;
16728 tpAniSirGlobal pMac;
16729
16730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16731 "%s:", __func__);
16732 if (NULL == pWdaParams)
16733 {
16734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16735 "%s: pWdaParams received NULL", __func__);
16736 VOS_ASSERT(0) ;
16737 return;
16738 }
16739
16740 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16741
16742 if (NULL == pWDA)
16743 {
16744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16745 "%s: pWDA received NULL", __func__);
16746 VOS_ASSERT(0);
16747 goto error;
16748 }
16749
16750 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16751 if (NULL == pMac)
16752 {
16753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16754 "%s:pMac is NULL", __func__);
16755 VOS_ASSERT(0);
16756 goto error;
16757 }
16758
16759 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16760
16761 if (pMac->sme.pEXTScanIndCb)
16762 {
16763 pMac->sme.pEXTScanIndCb(pCallbackContext,
16764 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
16765 pEventData);
16766 }
16767 else
16768 {
16769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16770 "%s:HDD callback is null", __func__);
16771 VOS_ASSERT(0);
16772 }
16773
16774
16775error:
16776
16777 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16778 {
16779 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16780 }
16781 if (pWdaParams->wdaMsgParam != NULL)
16782 {
16783 vos_mem_free(pWdaParams->wdaMsgParam);
16784 }
16785 vos_mem_free(pWdaParams) ;
16786
16787 return;
16788}
16789
16790/*==========================================================================
16791 FUNCTION WDA_ProcessEXTScanStartReq
16792
16793 DESCRIPTION
16794 API to send EXTScan Start Request to WDI
16795
16796 PARAMETERS
16797 pWDA: Pointer to WDA context
16798 wdaRequest: Pointer to EXTScan req parameters
16799===========================================================================*/
16800VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
16801 tSirEXTScanStartReqParams *wdaRequest)
16802{
16803 WDI_Status status = WDI_STATUS_SUCCESS;
16804 tWDA_ReqParams *pWdaParams;
16805
16806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16807 "%s: ", __func__);
16808 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16809 if (NULL == pWdaParams)
16810 {
16811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16812 "%s: VOS MEM Alloc Failure", __func__);
16813 VOS_ASSERT(0);
16814 return VOS_STATUS_E_NOMEM;
16815 }
16816 pWdaParams->pWdaContext = pWDA;
16817 pWdaParams->wdaMsgParam = wdaRequest;
16818 pWdaParams->wdaWdiApiMsgParam = NULL;
16819
16820 status = WDI_EXTScanStartReq((void *)wdaRequest,
16821 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
16822 (void *)pWdaParams);
16823 if (IS_WDI_STATUS_FAILURE(status))
16824 {
16825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16826 "Failure to request. Free all the memory " );
16827 vos_mem_free(pWdaParams->wdaMsgParam);
16828 vos_mem_free(pWdaParams);
16829 }
16830 return CONVERT_WDI2VOS_STATUS(status);
16831}
16832
16833/*==========================================================================
16834 FUNCTION WDA_ProcessEXTScanStopReq
16835
16836 DESCRIPTION
16837 API to send EXTScan Start Request to WDI
16838
16839 PARAMETERS
16840 pWDA: Pointer to WDA context
16841 wdaRequest: Pointer to EXTScan req parameters
16842===========================================================================*/
16843VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
16844 tSirEXTScanStopReqParams *wdaRequest)
16845{
16846 WDI_Status status = WDI_STATUS_SUCCESS;
16847 tWDA_ReqParams *pWdaParams;
16848
16849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16850 "%s:", __func__);
16851 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16852 if (NULL == pWdaParams)
16853 {
16854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16855 "%s: VOS MEM Alloc Failure", __func__);
16856 VOS_ASSERT(0);
16857 return VOS_STATUS_E_NOMEM;
16858 }
16859 pWdaParams->pWdaContext = pWDA;
16860 pWdaParams->wdaMsgParam = wdaRequest;
16861 pWdaParams->wdaWdiApiMsgParam = NULL;
16862
16863 status = WDI_EXTScanStopReq((void *)wdaRequest,
16864 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
16865 (void *)pWdaParams);
16866 if (IS_WDI_STATUS_FAILURE(status))
16867 {
16868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16869 "Failure to request. Free all the memory " );
16870 vos_mem_free(pWdaParams->wdaMsgParam);
16871 vos_mem_free(pWdaParams);
16872 }
16873 return CONVERT_WDI2VOS_STATUS(status);
16874}
16875
16876/*==========================================================================
16877 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
16878
16879 DESCRIPTION
16880 API to send EXTScan Get Cached Results Request to WDI
16881
16882 PARAMETERS
16883 pWDA: Pointer to WDA context
16884 wdaRequest: Pointer to EXTScan req parameters
16885===========================================================================*/
16886VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
16887 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
16888{
16889 WDI_Status status = WDI_STATUS_SUCCESS;
16890 tWDA_ReqParams *pWdaParams;
16891
16892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16893 "%s: ", __func__);
16894 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16895 if (NULL == pWdaParams)
16896 {
16897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16898 "%s: VOS MEM Alloc Failure", __func__);
16899 VOS_ASSERT(0);
16900 return VOS_STATUS_E_NOMEM;
16901 }
16902 pWdaParams->pWdaContext = pWDA;
16903 pWdaParams->wdaMsgParam = wdaRequest;
16904 pWdaParams->wdaWdiApiMsgParam = NULL;
16905
16906 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
16907 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
16908 (void *)pWdaParams);
16909 if (IS_WDI_STATUS_FAILURE(status))
16910 {
16911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16912 "Failure to request. Free all the memory " );
16913 vos_mem_free(pWdaParams->wdaMsgParam);
16914 vos_mem_free(pWdaParams);
16915 }
16916 return CONVERT_WDI2VOS_STATUS(status);
16917}
16918
16919/*==========================================================================
16920 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
16921
16922 DESCRIPTION
16923 API to send EXTScan Get Capabilities Request to WDI
16924
16925 PARAMETERS
16926 pWDA: Pointer to WDA context
16927 wdaRequest: Pointer to EXTScan req parameters
16928===========================================================================*/
16929VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
16930 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
16931{
16932 WDI_Status status = WDI_STATUS_SUCCESS;
16933 tWDA_ReqParams *pWdaParams;
16934
16935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16936 "%s:", __func__);
16937 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16938 if (NULL == pWdaParams)
16939 {
16940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16941 "%s: VOS MEM Alloc Failure", __func__);
16942 VOS_ASSERT(0);
16943 return VOS_STATUS_E_NOMEM;
16944 }
16945 pWdaParams->pWdaContext = pWDA;
16946 pWdaParams->wdaMsgParam = wdaRequest;
16947 pWdaParams->wdaWdiApiMsgParam = NULL;
16948
16949 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
16950 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
16951 (void *)pWdaParams);
16952 if (IS_WDI_STATUS_FAILURE(status))
16953 {
16954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16955 "Failure to request. Free all the memory " );
16956 vos_mem_free(pWdaParams->wdaMsgParam);
16957 vos_mem_free(pWdaParams);
16958 }
16959 return CONVERT_WDI2VOS_STATUS(status);
16960}
16961
16962/*==========================================================================
16963 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
16964
16965 DESCRIPTION
16966 API to send Set BSSID Hotlist Request to WDI
16967
16968 PARAMETERS
16969 pWDA: Pointer to WDA context
16970 wdaRequest: Pointer to EXTScan req parameters
16971===========================================================================*/
16972VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
16973 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
16974{
16975 WDI_Status status = WDI_STATUS_SUCCESS;
16976 tWDA_ReqParams *pWdaParams;
16977
16978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16979 "%s: ", __func__);
16980 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16981 if (NULL == pWdaParams)
16982 {
16983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16984 "%s: VOS MEM Alloc Failure", __func__);
16985 VOS_ASSERT(0);
16986 return VOS_STATUS_E_NOMEM;
16987 }
16988 pWdaParams->pWdaContext = pWDA;
16989 pWdaParams->wdaMsgParam = wdaRequest;
16990 pWdaParams->wdaWdiApiMsgParam = NULL;
16991
16992 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
16993 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
16994 (void *)pWdaParams);
16995 if (IS_WDI_STATUS_FAILURE(status))
16996 {
16997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16998 "Failure to request. Free all the memory " );
16999 vos_mem_free(pWdaParams->wdaMsgParam);
17000 vos_mem_free(pWdaParams);
17001 }
17002 return CONVERT_WDI2VOS_STATUS(status);
17003}
17004
17005/*==========================================================================
17006 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17007
17008 DESCRIPTION
17009 API to send Reset BSSID Hotlist Request to WDI
17010
17011 PARAMETERS
17012 pWDA: Pointer to WDA context
17013 wdaRequest: Pointer to EXTScan req parameters
17014===========================================================================*/
17015VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17016 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17017{
17018 WDI_Status status = WDI_STATUS_SUCCESS;
17019 tWDA_ReqParams *pWdaParams;
17020
17021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17022 "%s:", __func__);
17023 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17024 if (NULL == pWdaParams)
17025 {
17026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17027 "%s: VOS MEM Alloc Failure", __func__);
17028 VOS_ASSERT(0);
17029 return VOS_STATUS_E_NOMEM;
17030 }
17031 pWdaParams->pWdaContext = pWDA;
17032 pWdaParams->wdaMsgParam = wdaRequest;
17033 pWdaParams->wdaWdiApiMsgParam = NULL;
17034
17035 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17036 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17037 (void *)pWdaParams);
17038 if (IS_WDI_STATUS_FAILURE(status))
17039 {
17040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17041 "Failure to request. Free all the memory " );
17042 vos_mem_free(pWdaParams->wdaMsgParam);
17043 vos_mem_free(pWdaParams);
17044 }
17045 return CONVERT_WDI2VOS_STATUS(status);
17046}
17047
17048/*==========================================================================
17049 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17050
17051 DESCRIPTION
17052 API to send Set Significant RSSI Change Request to WDI
17053
17054 PARAMETERS
17055 pWDA: Pointer to WDA context
17056 wdaRequest: Pointer to EXTScan req parameters
17057===========================================================================*/
17058VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17059 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17060{
17061 WDI_Status status = WDI_STATUS_SUCCESS;
17062 tWDA_ReqParams *pWdaParams;
17063
17064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17065 "%s: ", __func__);
17066 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17067 if (NULL == pWdaParams)
17068 {
17069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17070 "%s: VOS MEM Alloc Failure", __func__);
17071 VOS_ASSERT(0);
17072 return VOS_STATUS_E_NOMEM;
17073 }
17074 pWdaParams->pWdaContext = pWDA;
17075 pWdaParams->wdaMsgParam = wdaRequest;
17076 pWdaParams->wdaWdiApiMsgParam = NULL;
17077
17078 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17079 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17080 (void *)pWdaParams);
17081 if (IS_WDI_STATUS_FAILURE(status))
17082 {
17083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17084 "Failure to request. Free all the memory " );
17085 vos_mem_free(pWdaParams->wdaMsgParam);
17086 vos_mem_free(pWdaParams);
17087 }
17088 return CONVERT_WDI2VOS_STATUS(status);
17089}
17090
17091/*==========================================================================
17092 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17093
17094 DESCRIPTION
17095 API to send Reset Significant RSSI Change Request to WDI
17096
17097 PARAMETERS
17098 pWDA: Pointer to WDA context
17099 wdaRequest: Pointer to EXTScan req parameters
17100===========================================================================*/
17101VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17102 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17103{
17104 WDI_Status status = WDI_STATUS_SUCCESS;
17105 tWDA_ReqParams *pWdaParams;
17106
17107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17108 "%s:", __func__);
17109 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17110 if (NULL == pWdaParams)
17111 {
17112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17113 "%s: VOS MEM Alloc Failure", __func__);
17114 VOS_ASSERT(0);
17115 return VOS_STATUS_E_NOMEM;
17116 }
17117 pWdaParams->pWdaContext = pWDA;
17118 pWdaParams->wdaMsgParam = wdaRequest;
17119 pWdaParams->wdaWdiApiMsgParam = NULL;
17120
17121 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17122 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17123 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17124 (void *)pWdaParams);
17125 if (IS_WDI_STATUS_FAILURE(status))
17126 {
17127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17128 "Failure to request. Free all the memory " );
17129 vos_mem_free(pWdaParams->wdaMsgParam);
17130 vos_mem_free(pWdaParams);
17131 }
17132 return CONVERT_WDI2VOS_STATUS(status);
17133}
17134#endif /* WLAN_FEATURE_EXTSCAN */
17135
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17136#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17137
17138/*==========================================================================
17139 FUNCTION WDA_LLStatsSetRspCallback
17140
17141 DESCRIPTION
17142 API to process set link layer statistics response from FW
17143
17144 PARAMETERS
17145 pRsp: Pointer to set link layer statistics response
17146 pUserData: Pointer to user data
17147
17148 RETURN VALUE
17149 NONE
17150
17151===========================================================================*/
17152void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17153{
17154 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17155
17156
17157 if (NULL == pWdaParams)
17158 {
17159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17160 "%s: pWdaParams received NULL", __func__);
17161 VOS_ASSERT(0) ;
17162 return ;
17163 }
17164
17165 /* Do not need to send notification to upper layer
17166 * Just free allocated resources */
17167 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17168 {
17169 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17170 }
17171 if (pWdaParams->wdaMsgParam != NULL)
17172 {
17173 vos_mem_free(pWdaParams->wdaMsgParam);
17174 }
17175 vos_mem_free(pWdaParams) ;
17176
17177 return;
17178}
17179
17180/*==========================================================================
17181 FUNCTION WDA_ProcessLLStatsSetReq
17182
17183 DESCRIPTION
17184 API to send Set Link Layer Stats request to WDI
17185
17186 PARAMETERS
17187 pWDA: Pointer to WDA context
17188 wdaRequest: Pointer to set Link Layer Stats req parameters
17189===========================================================================*/
17190VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17191 tSirLLStatsSetReq *wdaRequest)
17192{
17193 WDI_Status status = WDI_STATUS_SUCCESS;
17194 tWDA_ReqParams *pWdaParams;
17195
17196 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17197 if (NULL == pWdaParams)
17198 {
17199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17200 "%s: VOS MEM Alloc Failure", __func__);
17201 VOS_ASSERT(0);
17202 return VOS_STATUS_E_NOMEM;
17203 }
17204 pWdaParams->pWdaContext = pWDA;
17205 pWdaParams->wdaMsgParam = wdaRequest;
17206 pWdaParams->wdaWdiApiMsgParam = NULL;
17207
17208 status = WDI_LLStatsSetReq((void *)wdaRequest,
17209 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17210 (void *)pWdaParams);
17211 if (IS_WDI_STATUS_FAILURE(status))
17212 {
17213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17214 "Failure to request. Free all the memory " );
17215 vos_mem_free(pWdaParams->wdaMsgParam);
17216 vos_mem_free(pWdaParams);
17217 }
17218 return CONVERT_WDI2VOS_STATUS(status);
17219}
17220
17221/*==========================================================================
17222 FUNCTION WDA_LLStatsGetRspCallback
17223
17224 DESCRIPTION
17225 API to process get link layer statistics response from FW
17226
17227 PARAMETERS
17228 pRsp: Pointer to get link layer statistics response
17229 pUserData: Pointer to user data
17230
17231 RETURN VALUE
17232 NONE
17233
17234===========================================================================*/
17235void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17236{
17237 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17238
17239 if (NULL == pWdaParams)
17240 {
17241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17242 "%s: pWdaParams received NULL", __func__);
17243 VOS_ASSERT(0) ;
17244 return ;
17245 }
17246
17247 /* Do not need to send notification to upper layer
17248 * Just free allocated resources */
17249 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17250 {
17251 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17252 }
17253 if (pWdaParams->wdaMsgParam != NULL)
17254 {
17255 vos_mem_free(pWdaParams->wdaMsgParam);
17256 }
17257 vos_mem_free(pWdaParams) ;
17258
17259 return;
17260}
17261
17262/*==========================================================================
17263 FUNCTION WDA_ProcessLLStatsGetReq
17264
17265 DESCRIPTION
17266 API to send Get Link Layer Stats request to WDI
17267
17268 PARAMETERS
17269 pWDA: Pointer to WDA context
17270 wdaRequest: Pointer to get Link Layer Stats req parameters
17271===========================================================================*/
17272VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17273 tSirLLStatsGetReq *wdaRequest)
17274{
17275 WDI_Status status = WDI_STATUS_SUCCESS;
17276 tWDA_ReqParams *pWdaParams;
17277
17278 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17279 if (NULL == pWdaParams)
17280 {
17281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17282 "%s: VOS MEM Alloc Failure", __func__);
17283 VOS_ASSERT(0);
17284 return VOS_STATUS_E_NOMEM;
17285 }
17286 pWdaParams->pWdaContext = pWDA;
17287 pWdaParams->wdaMsgParam = wdaRequest;
17288 pWdaParams->wdaWdiApiMsgParam = NULL;
17289
17290 status = WDI_LLStatsGetReq((void *) wdaRequest,
17291 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17292 (void *)pWdaParams);
17293 if (IS_WDI_STATUS_FAILURE(status))
17294 {
17295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17296 "Failure to request. Free all the memory " );
17297 vos_mem_free(pWdaParams->wdaMsgParam);
17298 vos_mem_free(pWdaParams);
17299 }
17300 return CONVERT_WDI2VOS_STATUS(status);
17301}
17302
17303/*==========================================================================
17304 FUNCTION WDA_LLStatsClearRspCallback
17305
17306 DESCRIPTION
17307 API to process clear link layer statistics response from FW
17308
17309 PARAMETERS
17310 pRsp: Pointer to clear link layer statistics response
17311 pUserData: Pointer to user data
17312
17313 RETURN VALUE
17314 NONE
17315
17316===========================================================================*/
17317void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17318{
17319 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17320
17321
17322 if (NULL == pWdaParams)
17323 {
17324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17325 "%s: pWdaParams received NULL", __func__);
17326 VOS_ASSERT(0) ;
17327 return ;
17328 }
17329 /* Do not need to send notification to upper layer
17330 * Just free allocated resources */
17331 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17332 {
17333 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17334 }
17335 if (pWdaParams->wdaMsgParam != NULL)
17336 {
17337 vos_mem_free(pWdaParams->wdaMsgParam);
17338 }
17339 vos_mem_free(pWdaParams) ;
17340 return;
17341}
17342
17343/*==========================================================================
17344 FUNCTION WDA_ProcessLLStatsClearReq
17345
17346 DESCRIPTION
17347 API to send Clear Link Layer Stats request to WDI
17348
17349 PARAMETERS
17350 pWDA: Pointer to WDA context
17351 wdaRequest: Pointer to earLink Layer Stats req
17352===========================================================================*/
17353VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17354 tSirLLStatsClearReq *wdaRequest)
17355{
17356 WDI_Status status = WDI_STATUS_SUCCESS;
17357 tWDA_ReqParams *pWdaParams;
17358
17359 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17360 if (NULL == pWdaParams)
17361 {
17362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17363 "%s: VOS MEM Alloc Failure", __func__);
17364 VOS_ASSERT(0);
17365 return VOS_STATUS_E_NOMEM;
17366 }
17367 pWdaParams->pWdaContext = pWDA;
17368 pWdaParams->wdaMsgParam = wdaRequest;
17369 pWdaParams->wdaWdiApiMsgParam = NULL;
17370
17371 status = WDI_LLStatsClearReq((void *) wdaRequest,
17372 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17373 (void *)pWdaParams);
17374 if (IS_WDI_STATUS_FAILURE(status))
17375 {
17376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17377 "Failure to request. Free all the memory " );
17378 vos_mem_free(pWdaParams->wdaMsgParam);
17379 vos_mem_free(pWdaParams);
17380 }
17381 return CONVERT_WDI2VOS_STATUS(status);
17382}
17383
17384#endif /* WLAN_FEATURE_LINK_LAYER_STATS */