Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / f08a82b7c215bf3a33f7e30e45098b49a781e167 / . / CORE / WDA / src / wlan_qct_wda.c
blob: 0bfcf4abef57867ecb547c351c2c67483c03d5f5 [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/*
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]26 */
27
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]28
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]29
30
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]35 The functions externalized by this module are to be called ONLY by other
36 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]38 Are listed for each API below.
39
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]40 Copyright (c) 2010-2011 QUALCOMM Incorporated.
41 All Rights Reserved.
42 Qualcomm Confidential and Proprietary
43===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]45 EDIT HISTORY FOR FILE
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 This section contains comments describing changes made to the module.
48 Notice that changes are listed in reverse chronological order.
49
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]50 $Header$$DateTime$$Author$
51
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]52 when who what, where, why
53---------- --- -------------------------------------------------
5410/05/2011 haparna Adding support for Keep Alive Feature
552010-12-30 smiryala UMAC convergence changes
562010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
57===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]58#include "vos_mq.h"
59#include "vos_api.h"
60#include "vos_packet.h"
61#include "vos_nvitem.h"
62#include "sirApi.h"
63#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]64#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]65#include "wlan_qct_wda.h"
66#include "wlan_qct_wda_msg.h"
67#include "wlan_qct_wdi_cfg.h"
68#include "wlan_qct_wdi.h"
69#include "wlan_qct_wdi_ds.h"
70#include "wlan_hal_cfg.h"
71/**********************/
72#include "wniApi.h"
73#include "cfgApi.h"
74#include "limApi.h"
75#include "wlan_qct_tl.h"
76#include "wlan_qct_tli_ba.h"
77#include "limUtils.h"
78#include "btcApi.h"
79#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]80#include "pttMsgApi.h"
81#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82/* Used MACRO's */
83/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]84#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
86#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]88#define CONVERT_WDI2SIR_STATUS(x) \
89 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
90
91#define IS_WDI_STATUS_FAILURE(status) \
92 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]93#define CONVERT_WDI2VOS_STATUS(x) \
94 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
95
96/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]97#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#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]99#define WDA_GET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
101
102#define WDA_SET_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
104
105#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
106 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]107#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
108 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]109/* timer related Macros */
110#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
111 tx_timer_create(a, b, c, d, e, f, g)
112#define WDA_START_TIMER(a) tx_timer_activate(a)
113#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
114#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]115#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116
117#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
118 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]122#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]123#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]125#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]127#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]128#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
129 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
130 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
131
132#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
133#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]134#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]136/* extern declarations */
137extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]138extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* forward declarations */
141void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
142 void *pBodyptr, tANI_U32 bodyVal) ;
143VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
144 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]145VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
146VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
147
148extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
149 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]150void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]151void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
152 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
153void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
154 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
155void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
156 void* pUserData ) ;
157static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
158static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
159void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]160void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]162#ifdef WLAN_FEATURE_VOWIFI_11R
163VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
164#endif /* WLAN_FEATURE_VOWIFI_11R */
165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
167void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
168VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]169#ifdef FEATURE_WLAN_SCAN_PNO
170static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
171static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
172static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
173#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]174#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]175VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]176void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
177void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
178void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
179#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]180#ifdef WLAN_FEATURE_PACKET_FILTERING
181static VOS_STATUS WDA_Process8023MulticastListReq (
182 tWDA_CbContext *pWDA,
183 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
184 );
185static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
188 );
189static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
190 tWDA_CbContext *pWDA,
191 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
192 );
193static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
194 tWDA_CbContext *pWDA,
195 tSirRcvFltPktClearParam *pRcvFltPktClearParam
196 );
197#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]199static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
200 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]201VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
202 v_U8_t *pDefaultKeyId,
203 v_U8_t *pNumKeys,
204 WDI_KeysType *pWdiKeys );
205
206#ifdef WLAN_FEATURE_GTK_OFFLOAD
207static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
208static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
209#endif // WLAN_FEATURE_GTK_OFFLOAD
210
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]211v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
212 tSirBcnMissRateReq *pData);
213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]214VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
215 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]216#ifdef WLAN_FEATURE_11AC
217VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
218 tUpdateVHTOpMode *pData);
219#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]220
221#ifdef FEATURE_WLAN_LPHB
222VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
223 tSirLPHBReq *pData);
224#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]225
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]226#ifdef WLAN_FEATURE_EXTSCAN
227VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
228 tSirEXTScanStartReqParams *wdaRequest);
229VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
230 tSirEXTScanStopReqParams *wdaRequest);
231VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
232 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
234 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
236 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
238 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
243#endif /* WLAN_FEATURE_EXTSCAN */
244
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]245#ifdef WLAN_FEATURE_LINK_LAYER_STATS
246VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
247 tSirLLStatsSetReq *wdaRequest);
248
249VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
250 tSirLLStatsGetReq *wdaRequest);
251
252VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
253 tSirLLStatsClearReq *wdaRequest);
254#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]255/*
256 * FUNCTION: WDA_open
257 * Allocate the WDA context
258 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]259VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]260 tMacOpenParameters *pMacParams )
261{
262 tWDA_CbContext *wdaContext;
263 VOS_STATUS status;
264 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]265 /* Allocate WDA context */
266 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
267 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
268 if(!VOS_IS_STATUS_SUCCESS(status))
269 {
270 return VOS_STATUS_E_NOMEM;
271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]272 /*__asm int 3;*/
273 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
274
275 /* Initialize data structures */
276 wdaContext->pVosContext = pVosContext;
277 wdaContext->wdaState = WDA_INIT_STATE;
278 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
279
280 /* Initialize WDA-WDI synchronization event */
281 status = vos_event_init(&wdaContext->wdaWdiEvent);
282 if(!VOS_IS_STATUS_SUCCESS(status))
283 {
284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]285 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]286 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]288 /* Init Frame transfer event */
289 status = vos_event_init(&wdaContext->txFrameEvent);
290 if(!VOS_IS_STATUS_SUCCESS(status))
291 {
292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]293 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]294 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]296 status = vos_event_init(&wdaContext->suspendDataTxEvent);
297 if(!VOS_IS_STATUS_SUCCESS(status))
298 {
299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]300 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]301 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]303 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
304 if(!VOS_IS_STATUS_SUCCESS(status))
305 {
306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]307 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]308 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]311 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]312 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]313 &wdiDevCapability, pMacParams->driverType))
314 {
315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
316 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]317 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]318 }
319 else
320 {
321 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
322 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
323 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]324 /* update max STA in WDA used for BA */
325 wdaContext->wdaMaxSta = pMacParams->maxStation;
326 /* store the frameTransRequired flag in wdaContext, to send this to HAL
327 * in WDA_Start
328 */
329 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]331 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]332
333error:
334 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
335 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336}
337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]338/*
339 * FUNCTION: WDA_preStart
340 * Trigger DAL-AL to start CFG download
341 */
342VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
343{
344 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
345 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /*
347 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
348 */
349 wdaMsg.type = WNI_CFG_DNLD_REQ ;
350 wdaMsg.bodyptr = NULL;
351 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]352 /* post the message.. */
353 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
354 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
355 {
356 vosStatus = VOS_STATUS_E_BADMSG;
357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]358 return( vosStatus );
359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]360/*
361 * FUNCTION: WDA_wdiStartCallback
362 * Once WDI_Start is finished, WDI start callback will be called by WDI
363 * to indicate completion of WDI_Start.
364 */
365void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
366 void *pVosContext)
367{
368 tWDA_CbContext *wdaContext;
369 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 if (NULL == pVosContext)
371 {
372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]373 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]374 return;
375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]376 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
377 if (NULL == wdaContext)
378 {
379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]380 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]381 return;
382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]383 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
384 {
385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]386 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]387 }
388 else
389 {
390 wdaContext->wdaState = WDA_START_STATE;
391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 /* extract and save version information from the Start Response */
393 wdaContext->wcnssWlanCompiledVersion.major =
394 wdiRspParams->wlanCompiledVersion.major;
395 wdaContext->wcnssWlanCompiledVersion.minor =
396 wdiRspParams->wlanCompiledVersion.minor;
397 wdaContext->wcnssWlanCompiledVersion.version =
398 wdiRspParams->wlanCompiledVersion.version;
399 wdaContext->wcnssWlanCompiledVersion.revision =
400 wdiRspParams->wlanCompiledVersion.revision;
401 wdaContext->wcnssWlanReportedVersion.major =
402 wdiRspParams->wlanReportedVersion.major;
403 wdaContext->wcnssWlanReportedVersion.minor =
404 wdiRspParams->wlanReportedVersion.minor;
405 wdaContext->wcnssWlanReportedVersion.version =
406 wdiRspParams->wlanReportedVersion.version;
407 wdaContext->wcnssWlanReportedVersion.revision =
408 wdiRspParams->wlanReportedVersion.revision;
409 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
410 wdiRspParams->wcnssSoftwareVersion,
411 sizeof(wdaContext->wcnssSoftwareVersionString));
412 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
413 wdiRspParams->wcnssHardwareVersion,
414 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]415 /* Notify WDA_start that WDI_Start has completed */
416 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]417 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]418 {
419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]420 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]422 return;
423}
424
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]425/*
426 * FUNCTION: WDA_start
427 * Prepare TLV configuration and call WDI_Start.
428 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429VOS_STATUS WDA_start(v_PVOID_t pVosContext)
430{
431 tWDA_CbContext *wdaContext;
432 VOS_STATUS status;
433 WDI_Status wdiStatus;
434 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 if (NULL == pVosContext)
436 {
437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]438 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]439 return VOS_STATUS_E_FAILURE;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
442 if (NULL == wdaContext)
443 {
444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]445 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]446 return VOS_STATUS_E_FAILURE;
447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]448 /* Non-FTM mode, WDA status for START must be INIT
449 * FTM mode, WDA Status for START can be INIT or STOP */
450 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
451 (WDA_STOP_STATE != wdaContext->wdaState) )
452 {
453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
454 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]455 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]456 return VOS_STATUS_E_FAILURE;
457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 /* initialize the wdiStartParam. Note that we can create this on
459 the stack since we won't exit until WDI_Start() completes or
460 times out */
461 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]463 /* prepare the config TLV for the WDI */
464 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
465 if ( !VOS_IS_STATUS_SUCCESS(status) )
466 {
467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]468 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]469 return VOS_STATUS_E_FAILURE;
470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]471 /* note from here onwards if an error occurs we must
472 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]473 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
474 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
475 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]476 /* initialize the WDA-WDI synchronization event */
477 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]478 /* call WDI start */
479 wdiStatus = WDI_Start(&wdiStartParam,
480 (WDI_StartRspCb)WDA_wdiStartCallback,
481 (v_VOID_t *)pVosContext);
482 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
483 {
484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]485 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]486 vos_mem_free(wdiStartParam.pConfigBuffer);
487 return VOS_STATUS_E_FAILURE;
488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /* wait for WDI start to invoke our callback */
490 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
491 WDA_WDI_START_TIMEOUT );
492 if ( !VOS_IS_STATUS_SUCCESS(status) )
493 {
494 if ( VOS_STATUS_E_TIMEOUT == status )
495 {
496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]497 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 }
499 else
500 {
501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
502 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
505 vos_mem_free(wdiStartParam.pConfigBuffer);
506 return VOS_STATUS_E_FAILURE;
507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]509 /* we no longer need the config TLV */
510 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]511 /* if we are not in the START state then WDI_Start() failed */
512 if (WDA_START_STATE != wdaContext->wdaState)
513 {
514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]515 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]516 return VOS_STATUS_E_FAILURE;
517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 /* FTM mode does not need to monitor BA activity */
519 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
520 {
521 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]522 if(VOS_STATUS_SUCCESS == status)
523 {
524 wdaContext->wdaTimersCreated = VOS_TRUE;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]527 else
528 {
529 vos_event_init(&wdaContext->ftmStopDoneEvent);
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 return status;
532}
533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]534/*
535 * FUNCTION: WDA_prepareConfigTLV
536 * Function to prepare CFG for DAL(WDA)
537 */
538VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
539 WDI_StartReqParamsType *wdiStartParams )
540{
541 /* get pMac to acess CFG data base */
542 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
543 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
544 tHalCfg *tlvStruct = NULL ;
545 tANI_U8 *tlvStructStart = NULL ;
546 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
547 v_PVOID_t *configParam;
548 tANI_U32 configParamSize;
549 tANI_U32 *configDataValue;
550 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]551 tANI_U8 i;
552
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]553 if ((NULL == pMac)||(NULL == wdaContext))
554 {
555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]556 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]557 VOS_ASSERT(0);
558 return VOS_STATUS_E_FAILURE;
559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]560 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
561 WNI_CFG_STA_ID_LEN +
562 WNI_CFG_EDCA_WME_ACBK_LEN +
563 WNI_CFG_EDCA_WME_ACBE_LEN +
564 WNI_CFG_EDCA_WME_ACVI_LEN +
565 WNI_CFG_EDCA_WME_ACVO_LEN +
566 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]567 /* malloc memory for all configs in one shot */
568 configParam = vos_mem_malloc(configParamSize);
569
570 if(NULL == configParam )
571 {
572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]573 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]574 VOS_ASSERT(0) ;
575 return VOS_STATUS_E_NOMEM;
576 }
577 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]579 tlvStruct = (tHalCfg *)configParam;
580 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 /* TODO: Remove Later */
582 /* QWLAN_HAL_CFG_STA_ID */
583 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
584 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
585 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
586 eSIR_SUCCESS)
587 {
588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
589 "Failed to get value for WNI_CFG_STA_ID");
590 goto handle_failure;
591 }
592 tlvStruct->length = strLength ;
593 /* calculate the pad bytes to have the CFG in aligned format */
594 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
595 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]596 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
597 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]598 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
599 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
600 tlvStruct->length = sizeof(tANI_U32);
601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
602 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
603 != eSIR_SUCCESS)
604 {
605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
606 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
607 goto handle_failure;
608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]611 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
612 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
613 tlvStruct->length = sizeof(tANI_U32);
614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
615 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
616 eSIR_SUCCESS)
617 {
618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
619 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
620 goto handle_failure;
621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
623 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]624 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
625 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
626 tlvStruct->length = sizeof(tANI_U32);
627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
628 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
629 != eSIR_SUCCESS)
630 {
631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
632 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
633 goto handle_failure;
634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]635 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
636 + sizeof(tHalCfg) + tlvStruct->length)) ;
637
638 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
639 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
640 tlvStruct->length = sizeof(tANI_U32);
641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
642 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
643 configDataValue ) != eSIR_SUCCESS)
644 {
645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
646 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
647 goto handle_failure;
648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]649 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
650 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* QWLAN_HAL_CFG_CAL_PERIOD */
652 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
653 tlvStruct->length = sizeof(tANI_U32);
654 configDataValue = (tANI_U32 *)(tlvStruct + 1);
655 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
656 != eSIR_SUCCESS)
657 {
658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
659 "Failed to get value for WNI_CFG_CAL_PERIOD");
660 goto handle_failure;
661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
663 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]664 /* QWLAN_HAL_CFG_CAL_CONTROL */
665 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
666 tlvStruct->length = sizeof(tANI_U32);
667 configDataValue = (tANI_U32 *)(tlvStruct + 1);
668 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
669 != eSIR_SUCCESS)
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 "Failed to get value for WNI_CFG_CAL_CONTROL");
673 goto handle_failure;
674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]675 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
676 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]677 /* QWLAN_HAL_CFG_PROXIMITY */
678 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
679 tlvStruct->length = sizeof(tANI_U32);
680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
681 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
682 != eSIR_SUCCESS)
683 {
684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
685 "Failed to get value for WNI_CFG_PROXIMITY");
686 goto handle_failure;
687 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]688 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
689 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]690 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
691 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
692 tlvStruct->length = sizeof(tANI_U32);
693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
694 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
695 != eSIR_SUCCESS)
696 {
697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
698 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
699 goto handle_failure;
700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
702 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]703 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
704 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
705 tlvStruct->length = sizeof(tANI_U32);
706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
707 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
708 eSIR_SUCCESS)
709 {
710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
711 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
712 goto handle_failure;
713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]714 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
715 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]716 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
717 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
718 tlvStruct->length = sizeof(tANI_U32);
719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
720 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
721 configDataValue ) != eSIR_SUCCESS)
722 {
723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
724 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
725 goto handle_failure;
726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
728 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
730 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
731 tlvStruct->length = sizeof(tANI_U32);
732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
733 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
738 goto handle_failure;
739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]740 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
741 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]742 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
743 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
744 tlvStruct->length = sizeof(tANI_U32);
745 configDataValue = (tANI_U32 *)(tlvStruct + 1);
746 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
747 eSIR_SUCCESS)
748 {
749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
750 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
751 goto handle_failure;
752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]755 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
756 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
757 tlvStruct->length = sizeof(tANI_U32);
758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
759 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
760 eSIR_SUCCESS)
761 {
762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
763 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
764 goto handle_failure;
765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]766 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
767 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]768 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
769 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
770 tlvStruct->length = sizeof(tANI_U32);
771 configDataValue = (tANI_U32 *)(tlvStruct + 1);
772 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
773 configDataValue ) != eSIR_SUCCESS)
774 {
775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
776 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
777 goto handle_failure;
778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]779 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
780 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]781 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
782 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
783 tlvStruct->length = sizeof(tANI_U32);
784 configDataValue = (tANI_U32 *)(tlvStruct + 1);
785 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
786 configDataValue ) != eSIR_SUCCESS)
787 {
788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
789 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
790 goto handle_failure;
791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]792 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
793 + sizeof(tHalCfg) + tlvStruct->length));
794
795 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
796 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
797 tlvStruct->length = sizeof(tANI_U32);
798 configDataValue = (tANI_U32 *)(tlvStruct + 1);
799 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
800 configDataValue ) != eSIR_SUCCESS)
801 {
802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
803 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
804 goto handle_failure;
805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]806 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
807 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]808 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
809 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
810 tlvStruct->length = sizeof(tANI_U32);
811 configDataValue = (tANI_U32 *)(tlvStruct + 1);
812 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
813 configDataValue ) != eSIR_SUCCESS)
814 {
815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
816 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
817 goto handle_failure;
818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]819 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
820 + sizeof(tHalCfg) + tlvStruct->length));
821
822 /* QWLAN_HAL_CFG_FIXED_RATE */
823 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
824 tlvStruct->length = sizeof(tANI_U32);
825 configDataValue = (tANI_U32 *)(tlvStruct + 1);
826 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
827 != eSIR_SUCCESS)
828 {
829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
830 "Failed to get value for WNI_CFG_FIXED_RATE");
831 goto handle_failure;
832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]833 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
834 + sizeof(tHalCfg) + tlvStruct->length));
835
836 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
837 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
838 tlvStruct->length = sizeof(tANI_U32);
839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
840 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
841 != eSIR_SUCCESS)
842 {
843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
844 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
845 goto handle_failure;
846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]847 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
848 + sizeof(tHalCfg) + tlvStruct->length));
849
850 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
851 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
852 tlvStruct->length = sizeof(tANI_U32);
853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
854 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
855 configDataValue ) != eSIR_SUCCESS)
856 {
857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
858 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
859 goto handle_failure;
860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]861 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
862 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]863 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
864 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
865 tlvStruct->length = sizeof(tANI_U32);
866 configDataValue = (tANI_U32 *)(tlvStruct + 1);
867 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
868 configDataValue ) != eSIR_SUCCESS)
869 {
870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
871 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
872 goto handle_failure;
873 }
874 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
875 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]876 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
877 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
878 tlvStruct->length = sizeof(tANI_U32);
879 configDataValue = (tANI_U32 *)(tlvStruct + 1);
880 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
881 configDataValue ) != eSIR_SUCCESS)
882 {
883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
884 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
885 goto handle_failure;
886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]887 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
888 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]889 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
890 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
891 tlvStruct->length = sizeof(tANI_U32);
892 configDataValue = (tANI_U32 *)(tlvStruct + 1);
893 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
894 configDataValue ) != eSIR_SUCCESS)
895 {
896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
897 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
898 goto handle_failure;
899 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
901 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]902 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
903 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
904 tlvStruct->length = sizeof(tANI_U32);
905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
906 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
907 configDataValue ) != eSIR_SUCCESS)
908 {
909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
910 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
911 goto handle_failure;
912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
914 + sizeof(tHalCfg) + tlvStruct->length);
915
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
917 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
925 goto handle_failure;
926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]927 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
928 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]929 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
930 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
938 goto handle_failure;
939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]940 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
941 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]942 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
943 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
944 tlvStruct->length = sizeof(tANI_U32);
945 configDataValue = (tANI_U32 *)(tlvStruct + 1);
946 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
947 eSIR_SUCCESS)
948 {
949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
950 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
951 goto handle_failure;
952 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]953 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
954 + sizeof(tHalCfg) + tlvStruct->length);
955
956 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
957 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
965 goto handle_failure;
966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]967 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
968 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]969 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
970 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
971 tlvStruct->length = sizeof(tANI_U32);
972 configDataValue = (tANI_U32 *)(tlvStruct + 1);
973 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
974 configDataValue ) != eSIR_SUCCESS)
975 {
976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
977 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
978 goto handle_failure;
979 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]980 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
981 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]982 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
983 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
984 tlvStruct->length = sizeof(tANI_U32);
985 configDataValue = (tANI_U32 *)(tlvStruct + 1);
986 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
987 configDataValue ) != eSIR_SUCCESS)
988 {
989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
990 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
991 goto handle_failure;
992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]993 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
994 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
996 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
997 tlvStruct->length = sizeof(tANI_U32);
998 configDataValue = (tANI_U32 *)(tlvStruct + 1);
999 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1000 configDataValue ) != eSIR_SUCCESS)
1001 {
1002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1003 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1004 goto handle_failure;
1005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1006 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1007 + sizeof(tHalCfg) + tlvStruct->length);
1008
1009 /* QWLAN_HAL_CFG_STATS_PERIOD */
1010 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1011 tlvStruct->length = sizeof(tANI_U32);
1012 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1013 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1014 eSIR_SUCCESS)
1015 {
1016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1017 "Failed to get value for WNI_CFG_STATS_PERIOD");
1018 goto handle_failure;
1019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1021 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1022 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1023 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1024 tlvStruct->length = sizeof(tANI_U32);
1025 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1026 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1027 eSIR_SUCCESS)
1028 {
1029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1030 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1031 goto handle_failure;
1032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1034 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1036 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1037 tlvStruct->length = sizeof(tANI_U32);
1038 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1039 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1040 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1043 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1044 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1045 tlvStruct->length = sizeof(tANI_U32);
1046 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1047 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1048 != eSIR_SUCCESS)
1049 {
1050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1051 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1052 goto handle_failure;
1053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1054 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1055 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1056 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1057 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1058 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1059 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1060 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1061 &strLength) != eSIR_SUCCESS)
1062 {
1063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1064 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1065 goto handle_failure;
1066 }
1067 tlvStruct->length = strLength;
1068 /* calculate the pad bytes to have the CFG in aligned format */
1069 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1070 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1071 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1072 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1073 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1074 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1075 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1076 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1077 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1078 &strLength) != eSIR_SUCCESS)
1079 {
1080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1081 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1082 goto handle_failure;
1083 }
1084 tlvStruct->length = strLength;
1085 /* calculate the pad bytes to have the CFG in aligned format */
1086 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1087 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1091 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1092 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1095 &strLength) != eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1099 goto handle_failure;
1100 }
1101 tlvStruct->length = strLength;
1102 /* calculate the pad bytes to have the CFG in aligned format */
1103 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1104 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1105 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1106 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1107 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1108 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1109 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1110 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1111 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1112 &strLength) != eSIR_SUCCESS)
1113 {
1114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1115 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1116 goto handle_failure;
1117 }
1118 tlvStruct->length = strLength;
1119 /* calculate the pad bytes to have the CFG in aligned format */
1120 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1121 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1122 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1123 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1124 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1125 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1126 tlvStruct->length = sizeof(tANI_U32);
1127 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1128 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1129 != eSIR_SUCCESS)
1130 {
1131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1132 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1133 goto handle_failure;
1134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1135 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1136 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1137 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1138 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1139 tlvStruct->length = sizeof(tANI_U32);
1140 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1141 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1142 != eSIR_SUCCESS)
1143 {
1144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1145 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1146 goto handle_failure;
1147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1148 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1149 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1150 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1151 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1152 tlvStruct->length = sizeof(tANI_U32);
1153 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1154 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1155 != eSIR_SUCCESS)
1156 {
1157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1158 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1159 goto handle_failure;
1160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1162 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1163 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1164 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1165 tlvStruct->length = sizeof(tANI_U32);
1166 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1167 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1168 != eSIR_SUCCESS)
1169 {
1170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1171 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1172 goto handle_failure;
1173 }
1174 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1175 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1177 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1178 tlvStruct->length = sizeof(tANI_U32);
1179 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1180 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1181 != eSIR_SUCCESS)
1182 {
1183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1184 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1185 goto handle_failure;
1186 }
1187 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1188 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1190 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1191 tlvStruct->length = sizeof(tANI_U32);
1192 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1193 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1194 != eSIR_SUCCESS)
1195 {
1196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1197 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1198 goto handle_failure;
1199 }
1200 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1201 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1203 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1204 tlvStruct->length = sizeof(tANI_U32);
1205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1206 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1207 != eSIR_SUCCESS)
1208 {
1209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1210 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1211 goto handle_failure;
1212 }
1213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1214 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1215 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1216 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1217 tlvStruct->length = sizeof(tANI_U32);
1218 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1219 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1220 != eSIR_SUCCESS)
1221 {
1222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1223 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1224 goto handle_failure;
1225 }
1226 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1227 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1228 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1229 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1230 tlvStruct->length = sizeof(tANI_U32);
1231 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1232 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1233 != eSIR_SUCCESS)
1234 {
1235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1236 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1237 goto handle_failure;
1238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1239 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1240 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1241 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1242 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1243 tlvStruct->length = sizeof(tANI_U32);
1244 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1245 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1246 != eSIR_SUCCESS)
1247 {
1248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1249 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1250 goto handle_failure;
1251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1252 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1253 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1254 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1255 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1256 tlvStruct->length = sizeof(tANI_U32);
1257 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1258 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1259 != eSIR_SUCCESS)
1260 {
1261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1262 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1263 goto handle_failure;
1264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1265 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1266 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1267 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1268 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1269 * into FW, so the parameters are added here.
1270 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1271 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1272 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1273 tlvStruct->length = sizeof(tANI_U32);
1274 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1275 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1276 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1277 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1278 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1279 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1280 tlvStruct->length = sizeof(tANI_U32);
1281 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1282 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1286 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1290 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1291 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1292 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1293 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1294 tlvStruct->length = sizeof(tANI_U32);
1295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1296 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1297 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1298 + sizeof(tHalCfg) + tlvStruct->length) ;
1299
1300 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1301 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1302 tlvStruct->length = sizeof(tANI_U32);
1303 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1304 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1305 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1306 + sizeof(tHalCfg) + tlvStruct->length) ;
1307
1308 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1309 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1310 tlvStruct->length = sizeof(tANI_U32);
1311 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1312 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1313 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1314 + sizeof(tHalCfg) + tlvStruct->length) ;
1315
1316 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1317 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1321 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1322 + sizeof(tHalCfg) + tlvStruct->length) ;
1323
1324 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1325 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1329 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1330 + sizeof(tHalCfg) + tlvStruct->length) ;
1331
1332 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1333 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1334 tlvStruct->length = sizeof(tANI_U32);
1335 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1336 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1337 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1338 + sizeof(tHalCfg) + tlvStruct->length) ;
1339
1340 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1341 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1342 tlvStruct->length = sizeof(tANI_U32);
1343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1344 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1345 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1346 + sizeof(tHalCfg) + tlvStruct->length) ;
1347
1348 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1349 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1350 tlvStruct->length = sizeof(tANI_U32);
1351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1352 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
1355
1356 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1357 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1358 tlvStruct->length = sizeof(tANI_U32);
1359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1360 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
1363
1364 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1365 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1366 tlvStruct->length = sizeof(tANI_U32);
1367 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1368 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1369 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1370 + sizeof(tHalCfg) + tlvStruct->length) ;
1371
1372 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1373 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1374 tlvStruct->length = sizeof(tANI_U32);
1375 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1376 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1377 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1378 + sizeof(tHalCfg) + tlvStruct->length) ;
1379
1380 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1396 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1397 {
1398 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1399 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1400 tlvStruct->length = sizeof(tANI_U32);
1401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1402 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1403 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1404 + sizeof(tHalCfg) + tlvStruct->length) ;
1405
1406 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1407 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1408 tlvStruct->length = sizeof(tANI_U32);
1409 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1410 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1411 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1412 + sizeof(tHalCfg) + tlvStruct->length) ;
1413
1414 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1415 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1416 tlvStruct->length = sizeof(tANI_U32);
1417 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1418 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1419 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1420 + sizeof(tHalCfg) + tlvStruct->length) ;
1421
1422 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1423 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1424 tlvStruct->length = sizeof(tANI_U32);
1425 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1426 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1427 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1428 + sizeof(tHalCfg) + tlvStruct->length) ;
1429 }
1430
1431 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1432 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1433 tlvStruct->length = sizeof(tANI_U32);
1434 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1435 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1436 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1437 + sizeof(tHalCfg) + tlvStruct->length) ;
1438
1439 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1440 {
1441 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1442 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1443 tlvStruct->length = sizeof(tANI_U32);
1444 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1445 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1446 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1447 + sizeof(tHalCfg) + tlvStruct->length) ;
1448 }
1449
1450 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1451 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1452 tlvStruct->length = sizeof(tANI_U32);
1453 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1454 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1455 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1456 + sizeof(tHalCfg) + tlvStruct->length) ;
1457
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1458 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1459 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1460 tlvStruct->length = sizeof(tANI_U32);
1461 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1462 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1463 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1464 wcnssCompiledApiVersion.minor,
1465 wcnssCompiledApiVersion.version,
1466 wcnssCompiledApiVersion.revision);
1467 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1468 + sizeof(tHalCfg) + tlvStruct->length) ;
1469
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1470 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1471 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1472 tlvStruct->length = sizeof(tANI_U32);
1473 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1474 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1475 configDataValue ) != eSIR_SUCCESS)
1476 {
1477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1478 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1479 goto handle_failure;
1480 }
1481
1482 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1483 + sizeof(tHalCfg) + tlvStruct->length) ;
1484 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1485 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1486 tlvStruct->length = sizeof(tANI_U32);
1487 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1488 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1489 configDataValue ) != eSIR_SUCCESS)
1490 {
1491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1492 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1493 goto handle_failure;
1494 }
1495
1496 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1497 + sizeof(tHalCfg) + tlvStruct->length) ;
1498
1499 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1500 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1501 tlvStruct->length = sizeof(tANI_U32);
1502 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1503 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1504 != eSIR_SUCCESS)
1505 {
1506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1507 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1508 goto handle_failure;
1509 }
1510
1511 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1512 + sizeof(tHalCfg) + tlvStruct->length) ;
1513
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1514 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1515 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1516 tlvStruct->length = sizeof(tANI_U32);
1517 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1518 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1519 != eSIR_SUCCESS)
1520 {
1521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1522 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1523 goto handle_failure;
1524 }
1525
1526 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1527 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1528#ifdef WLAN_SOFTAP_VSTA_FEATURE
1529 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1533 != eSIR_SUCCESS)
1534 {
1535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1536 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1537 goto handle_failure;
1538 }
1539
1540 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1541 + sizeof(tHalCfg) + tlvStruct->length) ;
1542#endif
1543
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1544 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1545 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1546 tlvStruct->length = sizeof(tANI_U32);
1547 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1548
1549 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1550 != eSIR_SUCCESS)
1551 {
1552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1553 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1554 goto handle_failure;
1555 }
1556
1557 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1558 + sizeof(tHalCfg) + tlvStruct->length) ;
1559
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1560/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1561 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1562 tlvStruct->length = sizeof(tANI_U32);
1563 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1564 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1565 configDataValue ) != eSIR_SUCCESS)
1566 {
1567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1568 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1569 goto handle_failure;
1570 }
1571
1572 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1573 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1574#ifdef FEATURE_WLAN_TDLS
1575 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1576 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1577 tlvStruct->length = sizeof(tANI_U32);
1578 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1579 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1580 configDataValue ) != eSIR_SUCCESS)
1581 {
1582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1583 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1584 goto handle_failure;
1585 }
1586 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1587 + sizeof(tHalCfg) + tlvStruct->length) ;
1588
1589 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1590 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1594 configDataValue ) != eSIR_SUCCESS)
1595 {
1596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1597 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1598 goto handle_failure;
1599 }
1600 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1601 + sizeof(tHalCfg) + tlvStruct->length) ;
1602 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1603 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1607 configDataValue ) != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1611 goto handle_failure;
1612 }
1613 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1614 + sizeof(tHalCfg) + tlvStruct->length) ;
1615 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1616 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1617 tlvStruct->length = sizeof(tANI_U32);
1618 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1619 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1620 configDataValue ) != eSIR_SUCCESS)
1621 {
1622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1623 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1624 goto handle_failure;
1625 }
1626 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1627 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1628 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1629 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1630 tlvStruct->length = sizeof(tANI_U32);
1631 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1632 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1633 configDataValue ) != eSIR_SUCCESS)
1634 {
1635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1636 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1637 goto handle_failure;
1638 }
1639 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1640 + sizeof(tHalCfg) + tlvStruct->length) ;
1641
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1642#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1643
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1644 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1645 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1646 tlvStruct->length = sizeof(tANI_U32);
1647 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1648 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1649 configDataValue ) != eSIR_SUCCESS)
1650 {
1651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1652 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1653 goto handle_failure;
1654 }
1655
1656 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1657 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1658
1659 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1660 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1661 tlvStruct->length = sizeof(tANI_U32);
1662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1663 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1664 != eSIR_SUCCESS)
1665 {
1666 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1667 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1668 goto handle_failure;
1669 }
1670 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1671 + sizeof(tHalCfg) + tlvStruct->length));
1672
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1673 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1674 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1675 tlvStruct->length = sizeof(tANI_U32);
1676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1677 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1678 configDataValue ) != eSIR_SUCCESS)
1679 {
1680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1681 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1682 goto handle_failure;
1683 }
1684
1685 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1686 + sizeof(tHalCfg) + tlvStruct->length) ;
1687
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1688 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1689 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1690 tlvStruct->length = sizeof(tANI_U32);
1691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1692 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1693 configDataValue ) != eSIR_SUCCESS)
1694 {
1695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1696 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1697 goto handle_failure;
1698 }
1699 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1700 + sizeof(tHalCfg) + tlvStruct->length) ;
1701
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1702 /* QWLAN_HAL_CFG_ATH_DISABLE */
1703 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1704 tlvStruct->length = sizeof(tANI_U32);
1705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1706 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1707 configDataValue ) != eSIR_SUCCESS)
1708 {
1709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1710 "Failed to get value for WNI_CFG_ATH_DISABLE");
1711 goto handle_failure;
1712 }
1713 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1714 + sizeof(tHalCfg) + tlvStruct->length) ;
1715
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1717 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
1730 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1731 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1732 tlvStruct->length = sizeof(tANI_U32);
1733 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1734 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1735 configDataValue ) != eSIR_SUCCESS)
1736 {
1737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1738 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1739 goto handle_failure;
1740 }
1741 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1742 + sizeof(tHalCfg) + tlvStruct->length) ;
1743
1744 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1745 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1746 tlvStruct->length = sizeof(tANI_U32);
1747 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1748 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1749 configDataValue ) != eSIR_SUCCESS)
1750 {
1751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1752 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1753 goto handle_failure;
1754 }
1755 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1756 + sizeof(tHalCfg) + tlvStruct->length) ;
1757
1758 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1759 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1760 tlvStruct->length = sizeof(tANI_U32);
1761 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1762 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1763 configDataValue ) != eSIR_SUCCESS)
1764 {
1765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1766 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1767 goto handle_failure;
1768 }
1769 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1770 + sizeof(tHalCfg) + tlvStruct->length) ;
1771
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1772 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1773 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1774 tlvStruct->length = sizeof(tANI_U32);
1775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1776 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1777 configDataValue ) != eSIR_SUCCESS)
1778 {
1779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1780 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1781 goto handle_failure;
1782 }
1783 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1784 + sizeof(tHalCfg) + tlvStruct->length) ;
1785
1786 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1787 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1788 tlvStruct->length = sizeof(tANI_U32);
1789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1790 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1791 configDataValue ) != eSIR_SUCCESS)
1792 {
1793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1794 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1795 goto handle_failure;
1796 }
1797 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1798 + sizeof(tHalCfg) + tlvStruct->length) ;
1799
1800 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1801 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1802 tlvStruct->length = sizeof(tANI_U32);
1803 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1804 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1805 configDataValue ) != eSIR_SUCCESS)
1806 {
1807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1808 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1809 goto handle_failure;
1810 }
1811 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1812 + sizeof(tHalCfg) + tlvStruct->length) ;
1813
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1814 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1815 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1816 tlvStruct->length = sizeof(tANI_U32);
1817 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1818 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1819 configDataValue ) != eSIR_SUCCESS)
1820 {
1821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1822 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1823 goto handle_failure;
1824 }
1825 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1826 + sizeof(tHalCfg) + tlvStruct->length) ;
1827
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1828 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1829 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1830 tlvStruct->length = sizeof(tANI_U32);
1831 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1832
1833 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1834 configDataValue ) != eSIR_SUCCESS)
1835 {
1836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1837 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1838 goto handle_failure;
1839 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1840 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1841 + sizeof(tHalCfg) + tlvStruct->length) ;
1842
1843 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1844 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1845 tlvStruct->length = sizeof(tANI_U32);
1846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1847
1848 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1849 configDataValue ) != eSIR_SUCCESS)
1850 {
1851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1852 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1853 goto handle_failure;
1854 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1855 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1856 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1857
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1858 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1859 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1860 tlvStruct->length = sizeof(tANI_U32);
1861 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1862
1863 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1864 configDataValue ) != eSIR_SUCCESS)
1865 {
1866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1867 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1868 goto handle_failure;
1869 }
1870 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1871 + sizeof(tHalCfg) + tlvStruct->length) ;
1872
1873 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1874 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1875 tlvStruct->length = sizeof(tANI_U32);
1876 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1877
1878 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892
1893 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1894 configDataValue ) != eSIR_SUCCESS)
1895 {
1896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1897 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1898 goto handle_failure;
1899 }
1900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1901 + sizeof(tHalCfg) + tlvStruct->length) ;
1902
1903 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1904 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1905 tlvStruct->length = sizeof(tANI_U32);
1906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1907
1908 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1909 configDataValue ) != eSIR_SUCCESS)
1910 {
1911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1912 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1913 goto handle_failure;
1914 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1915 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1916 + sizeof(tHalCfg) + tlvStruct->length) ;
1917
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]1918 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
1919 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
1920 tlvStruct->length = sizeof(tANI_U32);
1921 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1922
1923 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
1924 configDataValue ) != eSIR_SUCCESS)
1925 {
1926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1927 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
1928 goto handle_failure;
1929 }
1930 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1931 + sizeof(tHalCfg) + tlvStruct->length) ;
1932
1933 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
1934 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
1935 tlvStruct->length = sizeof(tANI_U32);
1936 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1937
1938 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
1939 configDataValue ) != eSIR_SUCCESS)
1940 {
1941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1942 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
1943 goto handle_failure;
1944 }
1945 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1946 + sizeof(tHalCfg) + tlvStruct->length) ;
1947
1948 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
1949 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
1950 tlvStruct->length = sizeof(tANI_U32);
1951 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1952
1953 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
1954 configDataValue ) != eSIR_SUCCESS)
1955 {
1956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1957 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
1958 goto handle_failure;
1959 }
1960 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1961 + sizeof(tHalCfg) + tlvStruct->length) ;
1962
1963 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
1964 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
1965 tlvStruct->length = sizeof(tANI_U32);
1966 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1967
1968 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
1969 configDataValue ) != eSIR_SUCCESS)
1970 {
1971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1972 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
1973 goto handle_failure;
1974 }
1975 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1976 + sizeof(tHalCfg) + tlvStruct->length) ;
1977
1978 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
1979 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
1980 tlvStruct->length = sizeof(tANI_U32);
1981 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1982
1983 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
1984 configDataValue ) != eSIR_SUCCESS)
1985 {
1986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1987 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
1988 goto handle_failure;
1989 }
1990 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1991 + sizeof(tHalCfg) + tlvStruct->length) ;
1992
1993 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
1994 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
1995 tlvStruct->length = sizeof(tANI_U32);
1996 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1997
1998 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
1999 configDataValue ) != eSIR_SUCCESS)
2000 {
2001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2002 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2003 goto handle_failure;
2004 }
2005 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2006 + sizeof(tHalCfg) + tlvStruct->length) ;
2007
2008 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2009 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2010 tlvStruct->length = sizeof(tANI_U32);
2011 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2012
2013 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2014 configDataValue ) != eSIR_SUCCESS)
2015 {
2016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2017 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2018 goto handle_failure;
2019 }
2020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2021 + sizeof(tHalCfg) + tlvStruct->length) ;
2022
2023 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2024 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2025 tlvStruct->length = sizeof(tANI_U32);
2026 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2027
2028 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2029 configDataValue ) != eSIR_SUCCESS)
2030 {
2031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2032 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2033 goto handle_failure;
2034 }
2035 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2036 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu03d961b2014-09-19 16:45:00 +0530[diff] [blame]2037
2038 /* QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE */
2039 tlvStruct->type = QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE ;
2040 tlvStruct->length = sizeof(tANI_U32);
2041 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2042
2043 if (wlan_cfgGetInt(pMac, WNI_CFG_BURST_MODE_BE_TXOP_VALUE,
2044 configDataValue ) != eSIR_SUCCESS)
2045 {
2046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2047 "Failed to get value for WNI_CFG_BURST_MODE_BE_TXOP_VALUE");
2048 goto handle_failure;
2049 }
2050 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2051 + sizeof(tHalCfg) + tlvStruct->length) ;
2052
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2053 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2054#ifdef WLAN_DEBUG
2055 {
2056 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2057 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2058 "****** Dumping CFG TLV ***** ");
2059 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2060 {
2061 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2062 "%02x %02x %02x %02x %02x %02x %02x %02x",
2063 tlvStructStart[i],
2064 tlvStructStart[i+1],
2065 tlvStructStart[i+2],
2066 tlvStructStart[i+3],
2067 tlvStructStart[i+4],
2068 tlvStructStart[i+5],
2069 tlvStructStart[i+6],
2070 tlvStructStart[i+7]);
2071 }
2072 /* Dump the bytes in the last line*/
2073 for (; i < wdiStartParams->usConfigBufferLen; i++)
2074 {
2075 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2076 "%02x ",tlvStructStart[i]);
2077 }
2078 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2079 "**************************** ");
2080 }
2081#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2082 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2083handle_failure:
2084 vos_mem_free(configParam);
2085 return VOS_STATUS_E_FAILURE;
2086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2087/*
2088 * FUNCTION: WDA_wdiCompleteCB
2089 * call the voss call back function
2090 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2091void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2092{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2093 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2094 tWDA_CbContext *wdaContext;
2095
2096 if(NULL == pWdaParams)
2097 {
2098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2099 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2100 VOS_ASSERT(0) ;
2101 return ;
2102 }
2103
2104 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2105
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2106 if (NULL == wdaContext)
2107 {
2108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2109 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2110 return ;
2111 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2112
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2113 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2114 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2115 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2116 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2117 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2118 vos_mem_free(pWdaParams);
2119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2120 if(WDI_STATUS_SUCCESS != status)
2121 {
2122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2123 "WDI stop callback returned failure" );
2124 VOS_ASSERT(0) ;
2125 }
2126 else
2127 {
2128 wdaContext->wdaState = WDA_STOP_STATE;
2129 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2130
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2131 /* FTM Driver stop procedure should be synced.
2132 * Stop and Close will happen on same context */
2133 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2134 {
2135 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2136 {
2137 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2138 "%s: FTM Stop Event Set Fail", __func__);
2139 VOS_ASSERT(0);
2140 }
2141 }
2142
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2143 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2144 vos_WDAComplete_cback(wdaContext->pVosContext);
2145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2146 return ;
2147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148/*
2149 * FUNCTION: WDA_stop
2150 * call WDI_stop
2151 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2152VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2153{
2154 WDI_Status wdiStatus;
2155 VOS_STATUS status = VOS_STATUS_SUCCESS;
2156 WDI_StopReqParamsType *wdiStopReq;
2157 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2158 tWDA_ReqParams *pWdaParams ;
2159
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2160 if (NULL == pWDA)
2161 {
2162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2163 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2164 VOS_ASSERT(0);
2165 return VOS_STATUS_E_FAILURE;
2166 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2167 if (pWDA->wdiFailed == true)
2168 {
2169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2170 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2171 return VOS_STATUS_E_ALREADY;
2172 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2174 /* FTM mode stay START_STATE */
2175 if( (WDA_READY_STATE != pWDA->wdaState) &&
2176 (WDA_INIT_STATE != pWDA->wdaState) &&
2177 (WDA_START_STATE != pWDA->wdaState) )
2178 {
2179 VOS_ASSERT(0);
2180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2181 wdiStopReq = (WDI_StopReqParamsType *)
2182 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2183 if(NULL == wdiStopReq)
2184 {
2185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2186 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 VOS_ASSERT(0);
2188 return VOS_STATUS_E_NOMEM;
2189 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2191 wdiStopReq->wdiStopReason = reason;
2192 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2193
2194 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2195 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2196 {
2197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2198 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 VOS_ASSERT(0);
2200 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2201 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2202 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2203
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2204 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2205 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2206 {
2207 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2208 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2209 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2210
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2211 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2212 pWdaParams->wdaMsgParam = NULL;
2213 pWdaParams->pWdaContext = pWDA;
2214
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2215 /* call WDI stop */
2216 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2217 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2218
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2219 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2220 {
2221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2222 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2223 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2224 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2225 status = VOS_STATUS_E_FAILURE;
2226 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2227
2228 /* FTM Driver stop procedure should be synced.
2229 * Stop and Close will happen on same context */
2230 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2231 {
2232 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2233 WDI_RESPONSE_TIMEOUT);
2234 if (status != VOS_STATUS_SUCCESS)
2235 {
2236 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2237 "%s: FTM Stop Timepoout", __func__);
2238 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2239 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2240 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2241 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2242 return status;
2243}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2244/*
2245 * FUNCTION: WDA_close
2246 * call WDI_close and free the WDA context
2247 */
2248VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2249{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2250 VOS_STATUS status = VOS_STATUS_SUCCESS;
2251 WDI_Status wstatus;
2252 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2253 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2254 if (NULL == wdaContext)
2255 {
2256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2257 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2258 return VOS_STATUS_E_FAILURE;
2259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2260 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2261 (WDA_STOP_STATE != wdaContext->wdaState))
2262 {
2263 VOS_ASSERT(0);
2264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2265 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2266 wstatus = WDI_Close();
2267 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2268 {
2269 status = VOS_STATUS_E_FAILURE;
2270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2271 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2272 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2273 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2274 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2275 {
2276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2277 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2278 status = VOS_STATUS_E_FAILURE;
2279 }
2280
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2281 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2282 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2283 {
2284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2285 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 status = VOS_STATUS_E_FAILURE;
2287 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2288 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2289 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2290 {
2291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2292 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2293 status = VOS_STATUS_E_FAILURE;
2294 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2295 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2296 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2297 {
2298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2299 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2300 status = VOS_STATUS_E_FAILURE;
2301 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2302 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2303 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2304 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2305 {
2306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2307 "error in WDA close " );
2308 status = VOS_STATUS_E_FAILURE;
2309 }
2310 return status;
2311}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2312/*
2313 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2314 * returns 1 if the compiled version is greater than or equal to the input version
2315 */
2316
2317uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2318{
2319 VOS_STATUS status = VOS_STATUS_SUCCESS;
2320 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2321 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2322 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2323 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2324 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2325 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2326 (compiledVersion.revision >= revision)))
2327 return 1;
2328 else
2329 return 0;
2330}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2331/*
2332 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2333 * returns 1 if the compiled version is greater than or equal to the input version
2334 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2336{
2337 VOS_STATUS status = VOS_STATUS_SUCCESS;
2338 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2339 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2340 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2341 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2342 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2343 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2344 (reportedVersion.revision >= revision)))
2345 return 1;
2346 else
2347 return 0;
2348}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349/*
2350 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2351 * Returns the version of the WCNSS WLAN API with which the HOST
2352 * device driver was compiled
2353 */
2354VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2355 tSirVersionType *pVersion)
2356{
2357 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2358 if ((NULL == pvosGCtx) || (NULL == pVersion))
2359 {
2360 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2361 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2362 VOS_ASSERT(0);
2363 return VOS_STATUS_E_FAILURE;
2364 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2365 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2366 if (NULL == pWDA )
2367 {
2368 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2369 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2370 VOS_ASSERT(0);
2371 return VOS_STATUS_E_FAILURE;
2372 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2373 *pVersion = pWDA->wcnssWlanCompiledVersion;
2374 return VOS_STATUS_SUCCESS;
2375}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2376/*
2377 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2378 * Returns the version of the WCNSS WLAN API with which the WCNSS
2379 * device driver was compiled
2380 */
2381VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2382 tSirVersionType *pVersion)
2383{
2384 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2385 if ((NULL == pvosGCtx) || (NULL == pVersion))
2386 {
2387 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2388 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2389 VOS_ASSERT(0);
2390 return VOS_STATUS_E_FAILURE;
2391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2392 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2393 if (NULL == pWDA )
2394 {
2395 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2396 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2397 VOS_ASSERT(0);
2398 return VOS_STATUS_E_FAILURE;
2399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2400 *pVersion = pWDA->wcnssWlanReportedVersion;
2401 return VOS_STATUS_SUCCESS;
2402}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2403/*
2404 * FUNCTION: WDA_GetWcnssSoftwareVersion
2405 * Returns the WCNSS Software version string
2406 */
2407VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2408 tANI_U8 *pVersion,
2409 tANI_U32 versionBufferSize)
2410{
2411 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2412 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2413 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2414 if ((NULL == pvosGCtx) || (NULL == pVersion))
2415 {
2416 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2417 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 VOS_ASSERT(0);
2419 return VOS_STATUS_E_FAILURE;
2420 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2422 if (NULL == pWDA )
2423 {
2424 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2425 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2426 VOS_ASSERT(0);
2427 return VOS_STATUS_E_FAILURE;
2428 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2429 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2430 return VOS_STATUS_SUCCESS;
2431}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2432/*
2433 * FUNCTION: WDA_GetWcnssHardwareVersion
2434 * Returns the WCNSS Hardware version string
2435 */
2436VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2437 tANI_U8 *pVersion,
2438 tANI_U32 versionBufferSize)
2439{
2440 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2441 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2442 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2443 if ((NULL == pvosGCtx) || (NULL == pVersion))
2444 {
2445 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2446 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2447 VOS_ASSERT(0);
2448 return VOS_STATUS_E_FAILURE;
2449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2450 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2451 if (NULL == pWDA )
2452 {
2453 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2454 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2455 VOS_ASSERT(0);
2456 return VOS_STATUS_E_FAILURE;
2457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2459 return VOS_STATUS_SUCCESS;
2460}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2461/*
2462 * FUNCTION: WDA_WniCfgDnld
2463 * Trigger CFG Download
2464 */
2465VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2466{
2467 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2468 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2469
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2470 if (NULL == pMac )
2471 {
2472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2473 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2474 VOS_ASSERT(0);
2475 return VOS_STATUS_E_FAILURE;
2476 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2477 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2478 return vosStatus;
2479}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2480/* -----------------------------------------------------------------
2481 * WDI interface
2482 * -----------------------------------------------------------------
2483 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2484/*
2485 * FUNCTION: WDA_suspendDataTxCallback
2486 * call back function called from TL after suspend Transmission
2487 */
2488VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2489 v_U8_t* ucSTAId,
2490 VOS_STATUS vosStatus)
2491{
2492 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2494 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2495 if (NULL == pWDA )
2496 {
2497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2498 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2499 VOS_ASSERT(0);
2500 return VOS_STATUS_E_FAILURE;
2501 }
2502 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2503 {
2504 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2505 }
2506 else
2507 {
2508 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2509 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2510 /* Trigger the event to bring the WDA TL suspend function to come
2511 * out of wait*/
2512 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2513 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2514 {
2515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2516 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2518 /* If TL suspended had timedout before this callback was called, resume back
2519 * TL.*/
2520 if (pWDA->txSuspendTimedOut)
2521 {
2522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2523 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 WDA_ResumeDataTx(pWDA);
2525 pWDA->txSuspendTimedOut = FALSE;
2526 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2527 return VOS_STATUS_SUCCESS;
2528}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2529/*
2530 * FUNCTION: WDA_suspendDataTx
2531 * Update TL to suspend the data Transmission
2532 */
2533VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2534{
2535 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2536 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2537
2538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2539 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2540 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 if (pWDA->txSuspendTimedOut)
2542 {
2543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2544 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2545 return status;
2546 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2547 /* Reset the event to be not signalled */
2548 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2549 if(!VOS_IS_STATUS_SUCCESS(status))
2550 {
2551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2552 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2553 return VOS_STATUS_E_FAILURE;
2554 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2555 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2556 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2557 WDA_SuspendDataTxCallback);
2558 if(status != VOS_STATUS_SUCCESS)
2559 {
2560 return status;
2561 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2562 /* Wait for the event to be set by the TL, to get the response of
2563 * suspending the TX queues, this event should be set by the Callback
2564 * function called by TL*/
2565 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2566 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2567 if(!VOS_IS_STATUS_SUCCESS(status))
2568 {
2569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2570 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2571 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2572 /* Set this flag to true when TL suspend times out, so that when TL
2573 * suspend eventually happens and calls the callback, TL can be resumed
2574 * right away by looking at this flag when true.*/
2575 pWDA->txSuspendTimedOut = TRUE;
2576 }
2577 else
2578 {
2579 pWDA->txSuspendTimedOut = FALSE;
2580 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2581 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2582 {
2583 status = VOS_STATUS_SUCCESS;
2584 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2585 return status;
2586}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587/*
2588 * FUNCTION: WDA_resumeDataTx
2589 * Update TL to resume the data Transmission
2590 */
2591VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2592{
2593 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2594
2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2596 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2597
2598 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599 return status;
2600}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601/*
2602 * FUNCTION: WDA_InitScanReqCallback
2603 * Trigger Init SCAN callback
2604 */
2605void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2606{
2607 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2608 tWDA_CbContext *pWDA;
2609 tInitScanParams *pWDA_ScanParam ;
2610 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2612 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 if(NULL == pWdaParams)
2614 {
2615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2616 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2617 VOS_ASSERT(0) ;
2618 return ;
2619 }
2620 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2621 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 if(NULL == pWDA_ScanParam)
2623 {
2624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2625 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2626 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2627 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2628 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2629 return ;
2630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2631 if(WDI_STATUS_SUCCESS != wdiStatus)
2632 {
2633 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2634 if(VOS_STATUS_SUCCESS != status)
2635 {
2636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2637 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2638 }
2639 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2640 /* free WDI command buffer */
2641 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2642 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2643
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2644
2645 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2646 /* without converting the Status to Failure or Success Just
2647 pass the same status to lim */
2648 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2649 /* send SCAN RSP message back to PE */
2650 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651 return ;
2652}
2653
2654/*
2655 * FUNCTION: WDA_ProcessInitScanReq
2656 * Trigger Init SCAN in DAL
2657 */
2658VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2659 tInitScanParams *initScanParams)
2660{
2661 WDI_Status status = WDI_STATUS_SUCCESS ;
2662 WDI_InitScanReqParamsType *wdiInitScanParam =
2663 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2664 sizeof(WDI_InitScanReqParamsType)) ;
2665 tWDA_ReqParams *pWdaParams;
2666 tANI_U8 i = 0;
2667
2668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2669 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2670 if(NULL == wdiInitScanParam)
2671 {
2672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2673 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2674 VOS_ASSERT(0);
2675 return VOS_STATUS_E_NOMEM;
2676 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2677 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2678 if(NULL == pWdaParams)
2679 {
2680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2681 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2682 VOS_ASSERT(0);
2683 vos_mem_free(wdiInitScanParam);
2684 return VOS_STATUS_E_NOMEM;
2685 }
2686
2687 /* Copy init Scan params to WDI structure */
2688 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2689 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2690 sizeof(tSirMacAddr)) ;
2691 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2692 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2693 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2694 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2695 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2697 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2698 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2699 {
2700 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2701 initScanParams->scanEntry.bssIdx[i] ;
2702 }
2703
2704 /* if Frame length, copy macMgmtHdr or WDI structure */
2705 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2706 {
2707 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2708 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2709 }
2710 wdiInitScanParam->wdiReqStatusCB = NULL ;
2711
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2712 /* Store Init Req pointer, as this will be used for response */
2713 pWdaParams->pWdaContext = pWDA;
2714 pWdaParams->wdaMsgParam = initScanParams;
2715 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2716 /* first try to suspend TX */
2717 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2718 if(WDI_STATUS_SUCCESS != status)
2719 {
2720 goto handleWdiFailure;
2721 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2722 /* call DAL API to pass init scan request to DAL */
2723 status = WDI_InitScanReq(wdiInitScanParam,
2724 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 if(IS_WDI_STATUS_FAILURE(status))
2726 {
2727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2728 "error in WDA Init Scan, Resume Tx " );
2729 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2730 VOS_ASSERT(0) ;
2731
2732 goto handleWdiFailure;
2733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2734 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2735handleWdiFailure:
2736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2737 "Failure in WDI Api, free all the memory " );
2738 /* free WDI command buffer */
2739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2740 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2741 /* send Failure to PE */
2742 initScanParams->status = eSIR_FAILURE ;
2743 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2744 return CONVERT_WDI2VOS_STATUS(status) ;
2745}
2746
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747/*
2748 * FUNCTION: WDA_StartScanReqCallback
2749 * send Start SCAN RSP back to PE
2750 */
2751void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2752 void* pUserData)
2753{
2754 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2755 tWDA_CbContext *pWDA;
2756 tStartScanParams *pWDA_ScanParam;
2757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2758 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2759 if(NULL == pWdaParams)
2760 {
2761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2762 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2763 VOS_ASSERT(0) ;
2764 return ;
2765 }
2766 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2767 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 if(NULL == pWDA_ScanParam)
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: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2772 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2773 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2774 return ;
2775 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2776 if(NULL == pWdaParams->wdaWdiApiMsgParam)
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: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2780 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2781 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2782 return ;
2783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2784 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2785 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2786
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2787
2788 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2789 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2790 /* send SCAN RSP message back to PE */
2791 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2792 return ;
2793}
2794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2795/*
2796 * FUNCTION: WDA_ProcessStartScanReq
2797 * Trigger start SCAN in WDI
2798 */
2799VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2800 tStartScanParams *startScanParams)
2801{
2802 WDI_Status status = WDI_STATUS_SUCCESS;
2803 WDI_StartScanReqParamsType *wdiStartScanParams =
2804 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2805 sizeof(WDI_StartScanReqParamsType)) ;
2806 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2808 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809 if(NULL == wdiStartScanParams)
2810 {
2811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2812 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2813 VOS_ASSERT(0);
2814 return VOS_STATUS_E_NOMEM;
2815 }
2816 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2817 if(NULL == pWdaParams)
2818 {
2819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2820 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 VOS_ASSERT(0);
2822 vos_mem_free(wdiStartScanParams);
2823 return VOS_STATUS_E_NOMEM;
2824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2825 /* Copy init Scan params to WDI structure */
2826 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2827 wdiStartScanParams->wdiReqStatusCB = NULL ;
2828
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2829 /* Store Init Req pointer, as this will be used for response */
2830 /* store Params pass it to WDI */
2831 pWdaParams->pWdaContext = pWDA;
2832 pWdaParams->wdaMsgParam = startScanParams;
2833 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834 /* call DAL API to pass init scan request to DAL */
2835 status = WDI_StartScanReq(wdiStartScanParams,
2836 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2837 /* failure returned by WDI API */
2838 if(IS_WDI_STATUS_FAILURE(status))
2839 {
2840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2841 "Failure in Start Scan WDI API, free all the memory "
2842 "It should be due to previous abort scan." );
2843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2844 vos_mem_free(pWdaParams) ;
2845 startScanParams->status = eSIR_FAILURE ;
2846 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2848 return CONVERT_WDI2VOS_STATUS(status) ;
2849}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2850/*
2851 * FUNCTION: WDA_EndScanReqCallback
2852 * END SCAN callback
2853 */
2854void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2855{
2856 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2857 tWDA_CbContext *pWDA;
2858 tEndScanParams *endScanParam;
2859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2860 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2861 if(NULL == pWdaParams)
2862 {
2863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2864 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2865 VOS_ASSERT(0) ;
2866 return ;
2867 }
2868 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2869 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2870 if(NULL == endScanParam)
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: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2875 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2876 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2877 return ;
2878 }
2879
2880 /* Free WDI command buffer */
2881 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2882 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2884 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2885 /* send response back to PE */
2886 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2887 return ;
2888}
2889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2890/*
2891 * FUNCTION: WDA_ProcessEndScanReq
2892 * Trigger END SCAN in WDI
2893 */
2894VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2895 tEndScanParams *endScanParams)
2896{
2897 WDI_Status status = WDI_STATUS_SUCCESS;
2898 WDI_EndScanReqParamsType *wdiEndScanParams =
2899 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2900 sizeof(WDI_EndScanReqParamsType)) ;
2901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 if(NULL == wdiEndScanParams)
2905 {
2906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2908 VOS_ASSERT(0);
2909 return VOS_STATUS_E_NOMEM;
2910 }
2911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2912 if(NULL == pWdaParams)
2913 {
2914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2916 VOS_ASSERT(0);
2917 vos_mem_free(wdiEndScanParams);
2918 return VOS_STATUS_E_NOMEM;
2919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 /* Copy init Scan params to WDI structure */
2921 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2922 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2923 /* Store Init Req pointer, as this will be used for response */
2924 /* store Params pass it to WDI */
2925 pWdaParams->pWdaContext = pWDA;
2926 pWdaParams->wdaMsgParam = endScanParams;
2927 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2928 /* call DAL API to pass init scan request to DAL */
2929 status = WDI_EndScanReq(wdiEndScanParams,
2930 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2931 if(IS_WDI_STATUS_FAILURE(status))
2932 {
2933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2934 "Failure in End Scan WDI API, free all the memory "
2935 "It should be due to previous abort scan." );
2936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2937 vos_mem_free(pWdaParams) ;
2938 endScanParams->status = eSIR_FAILURE ;
2939 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2941 return CONVERT_WDI2VOS_STATUS(status) ;
2942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943/*
2944 * FUNCTION: WDA_FinishScanReqCallback
2945 * Trigger Finish SCAN callback
2946 */
2947void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2948{
2949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2950 tWDA_CbContext *pWDA;
2951 tFinishScanParams *finishScanParam;
2952 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2954 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2955 if(NULL == pWdaParams)
2956 {
2957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2958 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2959 VOS_ASSERT(0) ;
2960 return ;
2961 }
2962
2963 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2964 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2965 if(NULL == finishScanParam)
2966 {
2967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2968 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2969 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2971 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972 return ;
2973 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2975 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2976 /*
2977 * Now Resume TX, if we reached here means, TX is already suspended, we
2978 * have to resume it unconditionaly
2979 */
2980 status = WDA_ResumeDataTx(pWDA) ;
2981
2982 if(VOS_STATUS_SUCCESS != status)
2983 {
2984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2985 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2986 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2987 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2988 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2989 return ;
2990}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2991/*
2992 * FUNCTION: WDA_ProcessFinshScanReq
2993 * Trigger Finish SCAN in WDI
2994 */
2995VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2996 tFinishScanParams *finishScanParams)
2997{
2998 WDI_Status status = WDI_STATUS_SUCCESS;
2999 WDI_FinishScanReqParamsType *wdiFinishScanParams =
3000 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
3001 sizeof(WDI_FinishScanReqParamsType)) ;
3002 tWDA_ReqParams *pWdaParams ;
3003 tANI_U8 i = 0;
3004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3005 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 if(NULL == wdiFinishScanParams)
3007 {
3008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3009 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3010 VOS_ASSERT(0);
3011 return VOS_STATUS_E_NOMEM;
3012 }
3013 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3014 if(NULL == pWdaParams)
3015 {
3016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3017 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3018 VOS_ASSERT(0);
3019 vos_mem_free(wdiFinishScanParams);
3020 return VOS_STATUS_E_NOMEM;
3021 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3022 /* Copy init Scan params to WDI structure */
3023 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3024 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3025 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3027 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3028 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3029 finishScanParams->frameLength ;
3030 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3031 finishScanParams->currentOperChannel ;
3032 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3033 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3034 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3035 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3036 {
3037 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3038 finishScanParams->scanEntry.bssIdx[i] ;
3039 }
3040
3041
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3042 /* if Frame length, copy macMgmtHdr ro WDI structure */
3043 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3044 {
3045 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3046 &finishScanParams->macMgmtHdr,
3047 sizeof(WDI_MacMgmtHdr)) ;
3048 }
3049 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3050 /* Store Init Req pointer, as this will be used for response */
3051 /* store Params pass it to WDI */
3052 pWdaParams->pWdaContext = pWDA;
3053 pWdaParams->wdaMsgParam = finishScanParams;
3054 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3055 /* call DAL API to pass init scan request to DAL */
3056 status = WDI_FinishScanReq(wdiFinishScanParams,
3057 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3058
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3059
3060 /*
3061 * WDI API returns failure..
3062 */
3063 if(IS_WDI_STATUS_FAILURE( status))
3064 {
3065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3066 "Failure in Finish Scan WDI API, free all the memory " );
3067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3068 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3069 finishScanParams->status = eSIR_FAILURE ;
3070 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3071 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3072 return CONVERT_WDI2VOS_STATUS(status) ;
3073}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3074/*---------------------------------------------------------------------
3075 * ASSOC API's
3076 *---------------------------------------------------------------------
3077 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3078/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3079 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3080 * Trigger Init SCAN callback
3081 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3082void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3083{
3084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3085 tWDA_CbContext *pWDA;
3086 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3088 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 if(NULL == pWdaParams)
3090 {
3091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3092 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3093 VOS_ASSERT(0) ;
3094 return ;
3095 }
3096 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3097 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3098 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3099 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3100 /* reset macBSSID */
3101 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3102 /* reset macSTASelf */
3103 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3104 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3105 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3106 return ;
3107}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3108
3109/*
3110 * FUNCTION: WDA_JoinReqCallback
3111 * Free memory and send SWITCH CHANNEL RSP back to PE.
3112 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3113 */
3114void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3115{
3116 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3117 tWDA_CbContext *pWDA;
3118 tSwitchChannelParams *joinReqParam;
3119
3120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3121 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3122
3123 if(NULL == pWdaParams)
3124 {
3125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3126 "%s: pWdaParams received NULL", __func__);
3127 VOS_ASSERT(0);
3128 return;
3129 }
3130
3131 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3132 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3133 joinReqParam->status = wdiStatus;
3134
3135 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3136 {
3137 /* reset macBSSID */
3138 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3139 /* reset macSTASelf */
3140 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3141
3142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3143 vos_mem_free(pWdaParams);
3144 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3145 }
3146
3147 return;
3148}
3149
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3150/*
3151 * FUNCTION: WDA_ProcessJoinReq
3152 * Trigger Join REQ in WDI
3153 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3155 tSwitchChannelParams* joinReqParam)
3156{
3157 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3158 WDI_JoinReqParamsType *wdiJoinReqParam =
3159 (WDI_JoinReqParamsType *)vos_mem_malloc(
3160 sizeof(WDI_JoinReqParamsType)) ;
3161 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3163 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3164 if(NULL == wdiJoinReqParam)
3165 {
3166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3167 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3168 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3169 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3170 return VOS_STATUS_E_NOMEM;
3171 }
3172 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3173 if(NULL == pWdaParams)
3174 {
3175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3176 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3177 VOS_ASSERT(0);
3178 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3179 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3180 return VOS_STATUS_E_NOMEM;
3181 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3182
3183 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3184 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3185 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3186 {
3187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3188 "%s: received join request when BSSID or self-STA is NULL "
3189 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3190 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3191 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3192 VOS_ASSERT(0);
3193 vos_mem_free(wdiJoinReqParam);
3194 vos_mem_free(pWdaParams);
3195 joinReqParam->status = eSIR_FAILURE ;
3196 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3197 return VOS_STATUS_E_INVAL;
3198 }
3199
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3200 /* copy the BSSID for pWDA */
3201 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3202 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3203 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3204 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3205 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3206 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3207#ifdef WLAN_FEATURE_VOWIFI
3208 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3209 joinReqParam->maxTxPower ;
3210#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3211 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3212 joinReqParam->localPowerConstraint ;
3213#endif
3214 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3215 joinReqParam->secondaryChannelOffset ;
3216 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3217
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3218 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3219 wdiJoinReqParam->pUserData = pWdaParams;
3220
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3221 /* Store Init Req pointer, as this will be used for response */
3222 /* store Params pass it to WDI */
3223 pWdaParams->pWdaContext = pWDA;
3224 pWdaParams->wdaMsgParam = joinReqParam;
3225 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3226 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3227 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3228 if(IS_WDI_STATUS_FAILURE(status))
3229 {
3230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3231 "Failure in Join WDI API, free all the memory " );
3232 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3233 vos_mem_free(pWdaParams) ;
3234 joinReqParam->status = eSIR_FAILURE ;
3235 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3237 return CONVERT_WDI2VOS_STATUS(status) ;
3238}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239/*
3240 * FUNCTION: WDA_SwitchChannelReqCallback
3241 * send Switch channel RSP back to PE
3242 */
3243void WDA_SwitchChannelReqCallback(
3244 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3245{
3246 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3247 tWDA_CbContext *pWDA;
3248 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3250 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3251 if(NULL == pWdaParams)
3252 {
3253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3254 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3255 VOS_ASSERT(0) ;
3256 return ;
3257 }
3258 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3259 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3260
3261#ifdef WLAN_FEATURE_VOWIFI
3262 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3263#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3264 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3265 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3266 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3267 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3268 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3269 return ;
3270}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3271/*
3272 * FUNCTION: WDA_ProcessChannelSwitchReq
3273 * Request to WDI to switch channel REQ params.
3274 */
3275VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3276 tSwitchChannelParams *pSwitchChanParams)
3277{
3278 WDI_Status status = WDI_STATUS_SUCCESS ;
3279 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3280 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3281 sizeof(WDI_SwitchChReqParamsType)) ;
3282 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3284 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 if(NULL == wdiSwitchChanParam)
3286 {
3287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3288 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3289 VOS_ASSERT(0);
3290 return VOS_STATUS_E_NOMEM;
3291 }
3292 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3293 if(NULL == pWdaParams)
3294 {
3295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3296 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3297 VOS_ASSERT(0);
3298 vos_mem_free(wdiSwitchChanParam);
3299 return VOS_STATUS_E_NOMEM;
3300 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3301 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3302#ifndef WLAN_FEATURE_VOWIFI
3303 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3304 pSwitchChanParams->localPowerConstraint;
3305#endif
3306 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3307 pSwitchChanParams->secondaryChannelOffset;
3308 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3309 /* Store req pointer, as this will be used for response */
3310 /* store Params pass it to WDI */
3311 pWdaParams->pWdaContext = pWDA;
3312 pWdaParams->wdaMsgParam = pSwitchChanParams;
3313 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3314#ifdef WLAN_FEATURE_VOWIFI
3315 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3316 = pSwitchChanParams->maxTxPower;
3317 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3318 pSwitchChanParams ->selfStaMacAddr,
3319 sizeof(tSirMacAddr));
3320#endif
3321 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3322 pSwitchChanParams->bssId,
3323 sizeof(tSirMacAddr));
3324
3325 status = WDI_SwitchChReq(wdiSwitchChanParam,
3326 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3327 if(IS_WDI_STATUS_FAILURE(status))
3328 {
3329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3330 "Failure in process channel switch Req WDI API, free all the memory " );
3331 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3332 vos_mem_free(pWdaParams) ;
3333 pSwitchChanParams->status = eSIR_FAILURE ;
3334 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3335 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3336 return CONVERT_WDI2VOS_STATUS(status) ;
3337}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3338
3339/*
3340 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3341 * send Switch channel RSP back to PE
3342 */
3343void WDA_SwitchChannelReqCallback_V1(
3344 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3345 void* pUserData)
3346{
3347 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3348 tWDA_CbContext *pWDA;
3349 tSwitchChannelParams *pSwitchChanParams;
3350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3351 "<------ %s " ,__func__);
3352
3353 if (NULL == pWdaParams)
3354 {
3355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3356 "%s: pWdaParams received NULL", __func__);
3357 VOS_ASSERT(0);
3358 return ;
3359 }
3360 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3361 pSwitchChanParams =
3362 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3363 pSwitchChanParams->channelSwitchSrc =
3364 wdiSwitchChanRsp->channelSwitchSrc;
3365#ifdef WLAN_FEATURE_VOWIFI
3366 pSwitchChanParams->txMgmtPower =
3367 wdiSwitchChanRsp->ucTxMgmtPower;
3368#endif
3369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3370 vos_mem_free(pWdaParams);
3371 pSwitchChanParams->status =
3372 wdiSwitchChanRsp->wdiStatus ;
3373 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3374 (void *)pSwitchChanParams , 0);
3375 return;
3376}
3377
3378/*
3379 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3380 * Request to WDI to switch channel REQ params.
3381 */
3382VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3383 tSwitchChannelParams *pSwitchChanParams)
3384{
3385 WDI_Status status = WDI_STATUS_SUCCESS ;
3386 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3387 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3388 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3389 tWDA_ReqParams *pWdaParams ;
3390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3391 "------> %s " ,__func__);
3392 if (NULL == wdiSwitchChanParam)
3393 {
3394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3395 "%s: VOS MEM Alloc Failure", __func__);
3396 VOS_ASSERT(0);
3397 return VOS_STATUS_E_NOMEM;
3398 }
3399 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3400 if (NULL == pWdaParams)
3401 {
3402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3403 "%s: VOS MEM Alloc Failure", __func__);
3404 VOS_ASSERT(0);
3405 vos_mem_free(wdiSwitchChanParam);
3406 return VOS_STATUS_E_NOMEM;
3407 }
3408 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3409 pSwitchChanParams->channelSwitchSrc;
3410
3411 wdiSwitchChanParam->wdiChInfo.ucChannel =
3412 pSwitchChanParams->channelNumber;
3413#ifndef WLAN_FEATURE_VOWIFI
3414 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3415 pSwitchChanParams->localPowerConstraint;
3416#endif
3417 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3418 pSwitchChanParams->secondaryChannelOffset;
3419 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3420 /* Store req pointer, as this will be used for response */
3421 /* store Params pass it to WDI */
3422 pWdaParams->pWdaContext = pWDA;
3423 pWdaParams->wdaMsgParam = pSwitchChanParams;
3424 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3425#ifdef WLAN_FEATURE_VOWIFI
3426 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3427 pSwitchChanParams->maxTxPower;
3428 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3429 pSwitchChanParams ->selfStaMacAddr,
3430 sizeof(tSirMacAddr));
3431#endif
3432 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3433 pSwitchChanParams->bssId,
3434 sizeof(tSirMacAddr));
3435
3436 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3437 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3438 pWdaParams);
3439 if (IS_WDI_STATUS_FAILURE(status))
3440 {
3441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3442 "Failure in process channel switch Req WDI "
3443 "API, free all the memory " );
3444 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3445 vos_mem_free(pWdaParams) ;
3446 pSwitchChanParams->status = eSIR_FAILURE ;
3447 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3448 (void *)pSwitchChanParams, 0) ;
3449 }
3450 return CONVERT_WDI2VOS_STATUS(status) ;
3451}
3452
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3453/*
3454 * FUNCTION: WDA_ConfigBssReqCallback
3455 * config BSS Req Callback, called by WDI
3456 */
3457void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3458 ,void* pUserData)
3459{
3460 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3461 tWDA_CbContext *pWDA;
3462 tAddBssParams *configBssReqParam;
3463 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3465 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 if(NULL == pWdaParams)
3467 {
3468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3469 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3470 VOS_ASSERT(0) ;
3471 return ;
3472 }
3473 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3474 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3475 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3476 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3477 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3478 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3479 {
3480 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3481 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3482 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3483 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3484 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3485
3486 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3487 {
3488 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3489 {
3490 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3491 staConfigBssParam->staType = STA_ENTRY_BSSID;
3492 }
3493 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3494 (staConfigBssParam->staType == STA_ENTRY_SELF))
3495 {
3496 /* This is the 1st add BSS Req for the BTAMP STA */
3497 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3498 staConfigBssParam->staType = STA_ENTRY_BSSID;
3499 }
3500 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3501 (staConfigBssParam->staType == STA_ENTRY_PEER))
3502 {
3503 /* This is the 2nd ADD BSS Request that is sent
3504 * on the BTAMP STA side. The Sta type is
3505 * set to STA_ENTRY_PEER here.*/
3506 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3507 }
3508 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3509 (staConfigBssParam->staType == STA_ENTRY_SELF))
3510 {
3511 /* statype is already set by PE.
3512 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3513 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3514 staConfigBssParam->staType = STA_ENTRY_BSSID;
3515 }
3516 else
3517 {
3518 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3519 staConfigBssParam->staType = STA_ENTRY_PEER;
3520 }
3521 }
3522 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3523 {
3524 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3525 staConfigBssParam->staType = STA_ENTRY_SELF;
3526 }
3527 else
3528 {
3529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3530 "Invalid operation mode specified");
3531 VOS_ASSERT(0);
3532 }
3533
3534 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3535 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3536 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3537 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3538 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3539 sizeof(tSirMacAddr));
3540 staConfigBssParam->txChannelWidthSet =
3541 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3542 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3543 staConfigBssParam->htCapable)
3544 {
3545 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3546 wdiConfigBssRsp->ucBSSIdx;
3547 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3548 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3549 pWDA->wdaStaInfo[staConfigBssParam->staIdx].currentOperChan =
3550 configBssReqParam->currentOperChannel;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3552 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3553 wdiConfigBssRsp->ucBSSIdx,
3554 wdiConfigBssRsp->ucSTAIdx))
3555 {
3556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3557 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 VOS_ASSERT(0) ;
3559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3560 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3561 {
3562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3563 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3564 VOS_ASSERT(0) ;
3565 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3566#ifdef WLAN_FEATURE_VOWIFI
3567 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3568#endif
3569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3570 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3571 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3573 return ;
3574}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3575/*
3576 * FUNCTION: WDA_UpdateEdcaParamsForAC
3577 * Update WDI EDCA params with PE edca params
3578 */
3579void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3580 WDI_EdcaParamRecord *wdiEdcaParam,
3581 tSirMacEdcaParamRecord *macEdcaParam)
3582{
3583 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3584 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3585 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3586 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3587 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3588 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3589}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3590/*
3591 * FUNCTION: WDA_ProcessConfigBssReq
3592 * Configure BSS before starting Assoc with AP
3593 */
3594VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3595 tAddBssParams* configBssReqParam)
3596{
3597 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3598 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3599 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3601 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3602 if (NULL == configBssReqParam)
3603 {
3604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3605 "%s: configBssReqParam is NULL", __func__);
3606 return VOS_STATUS_E_INVAL;
3607 }
3608
3609 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3610 sizeof(WDI_ConfigBSSReqParamsType)) ;
3611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3612 if(NULL == wdiConfigBssReqParam)
3613 {
3614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3615 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3616 VOS_ASSERT(0);
3617 return VOS_STATUS_E_NOMEM;
3618 }
3619 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3620 if(NULL == pWdaParams)
3621 {
3622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3623 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3624 VOS_ASSERT(0);
3625 vos_mem_free(wdiConfigBssReqParam);
3626 return VOS_STATUS_E_NOMEM;
3627 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3629 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3630 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3631 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3632 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633 /* Store Init Req pointer, as this will be used for response */
3634 /* store Params pass it to WDI */
3635 pWdaParams->pWdaContext = pWDA;
3636 pWdaParams->wdaMsgParam = configBssReqParam;
3637 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3638 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3639 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3640 if(IS_WDI_STATUS_FAILURE(status))
3641 {
3642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3643 "Failure in Config BSS WDI API, free all the memory " );
3644 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3645 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3646 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3647 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3649 return CONVERT_WDI2VOS_STATUS(status) ;
3650}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3651#ifdef ENABLE_HAL_COMBINED_MESSAGES
3652/*
3653 * FUNCTION: WDA_PostAssocReqCallback
3654 * Post ASSOC req callback, send RSP back to PE
3655 */
3656void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3657 void* pUserData)
3658{
3659 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3660 tPostAssocParams *postAssocReqParam =
3661 (tPostAssocParams *)pWDA->wdaMsgParam ;
3662 /*STA context within the BSS Params*/
3663 tAddStaParams *staPostAssocParam =
3664 &postAssocReqParam->addBssParams.staContext ;
3665 /*STA Params for self STA*/
3666 tAddStaParams *selfStaPostAssocParam =
3667 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3669 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3671 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3672 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3673 {
3674 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3675 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3676 sizeof(tSirMacAddr)) ;
3677 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3678 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3679 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3680 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3681 }
3682 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3683 pWDA->wdaWdiApiMsgParam = NULL;
3684 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3686 return ;
3687}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3688/*
3689 * FUNCTION: WDA_ProcessPostAssocReq
3690 * Trigger POST ASSOC processing in WDI
3691 */
3692VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3693 tPostAssocParams *postAssocReqParam)
3694{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3695 WDI_Status status = WDI_STATUS_SUCCESS ;
3696
3697 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3698 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3699 sizeof(WDI_PostAssocReqParamsType)) ;
3700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3701 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3702
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3703 if(NULL == wdiPostAssocReqParam)
3704 {
3705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3706 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3707 VOS_ASSERT(0);
3708 return VOS_STATUS_E_NOMEM;
3709 }
3710
3711 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3712 {
3713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3714 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3715 VOS_ASSERT(0);
3716 return VOS_STATUS_E_FAILURE;
3717 }
3718
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3719 /* update BSS params into WDI structure */
3720 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3721 &postAssocReqParam->addBssParams) ;
3722 /* update STA params into WDI structure */
3723 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3724 &postAssocReqParam->addStaParams) ;
3725
3726 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3727 postAssocReqParam->addBssParams.highPerformance;
3728 WDA_UpdateEdcaParamsForAC(pWDA,
3729 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3730 &postAssocReqParam->addBssParams.acbe);
3731 WDA_UpdateEdcaParamsForAC(pWDA,
3732 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3733 &postAssocReqParam->addBssParams.acbk);
3734 WDA_UpdateEdcaParamsForAC(pWDA,
3735 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3736 &postAssocReqParam->addBssParams.acvi);
3737 WDA_UpdateEdcaParamsForAC(pWDA,
3738 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3739 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3740 /* Store Init Req pointer, as this will be used for response */
3741 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3742 /* store Params pass it to WDI */
3743 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3744 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3745 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3746 if(IS_WDI_STATUS_FAILURE(status))
3747 {
3748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3749 "Failure in Post Assoc WDI API, free all the memory " );
3750 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3751 pWDA->wdaWdiApiMsgParam = NULL;
3752 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3753 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3754 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3755 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3756 return CONVERT_WDI2VOS_STATUS(status) ;
3757}
3758#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759/*
3760 * FUNCTION: WDA_AddStaReqCallback
3761 * ADD STA req callback, send RSP back to PE
3762 */
3763void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3764 void* pUserData)
3765{
3766 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3767 tWDA_CbContext *pWDA;
3768 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3770 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3771 if(NULL == pWdaParams)
3772 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3773 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]3774 VOS_ASSERT(0) ;
3775 return ;
3776 }
3777 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3778 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3779 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3780 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3781 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3782 {
3783 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3784 /*TODO: UMAC structure doesn't have these fields*/
3785 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3786 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3787 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3788 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3789 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3790 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3791#ifdef FEATURE_WLAN_TDLS
3792 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3793 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3794#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3795 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3796#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3797 {
3798 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3799 wdiConfigStaRsp->ucBssIdx;
3800 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3801 WDA_VALID_STA_INDEX ;
Abhishek Singhf08a82b2014-10-07 11:00:42 +0530[diff] [blame^]3802 pWDA->wdaStaInfo[addStaReqParam->staIdx].currentOperChan =
3803 addStaReqParam->currentOperChan;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3804 }
3805 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3806 {
3807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3808 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3809 VOS_ASSERT(0) ;
3810 return ;
3811 }
3812 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3813 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3814 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3815 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3816 return ;
3817}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3818/*
3819 * FUNCTION: WDA_ConfigStaReq
3820 * Trigger Config STA processing in WDI
3821 */
3822VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3823 tAddStaParams *addStaReqParam)
3824{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3825 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3826 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3827 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3828 sizeof(WDI_ConfigSTAReqParamsType)) ;
3829 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3831 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3832 if(NULL == wdiConfigStaReqParam)
3833 {
3834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3835 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3836 VOS_ASSERT(0);
3837 return VOS_STATUS_E_NOMEM;
3838 }
3839 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3840 if(NULL == pWdaParams)
3841 {
3842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3843 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3844 VOS_ASSERT(0);
3845 vos_mem_free(wdiConfigStaReqParam);
3846 return VOS_STATUS_E_NOMEM;
3847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3848 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3849 /* update STA params into WDI structure */
3850 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3851 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3852 /* Store Init Req pointer, as this will be used for response */
3853 /* store Params pass it to WDI */
3854 pWdaParams->pWdaContext = pWDA;
3855 pWdaParams->wdaMsgParam = addStaReqParam;
3856 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3857 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3858 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3859 if(IS_WDI_STATUS_FAILURE(status))
3860 {
3861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3862 "Failure in Config STA WDI API, free all the memory " );
3863 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3864 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3865 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3866 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3867 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3868 return CONVERT_WDI2VOS_STATUS(status) ;
3869}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3870/*
3871 * FUNCTION: WDA_DelBSSReqCallback
3872 * Dens DEL BSS RSP back to PE
3873 */
3874void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3875 void* pUserData)
3876{
3877 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3878 tWDA_CbContext *pWDA;
3879 tDeleteBssParams *delBssReqParam;
3880 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3882 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3883 if(NULL == pWdaParams)
3884 {
3885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3886 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3887 VOS_ASSERT(0) ;
3888 return ;
3889 }
3890 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3891 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3892 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3893 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3894 {
3895 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3896 sizeof(tSirMacAddr)) ;
3897 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3898 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3899 {
3900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3901 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3902 VOS_ASSERT(0) ;
3903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3904 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3905 {
3906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3907 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3908 VOS_ASSERT(0) ;
3909 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3910 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
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: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3914 VOS_ASSERT(0) ;
3915 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3916
3917 WLANTL_StartForwarding(staIdx,0,0);
3918
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 /* reset the the system role*/
3922 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3923
3924 /* Reset the BA related information */
3925 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3926 {
3927 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3928 {
3929 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3930 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3931 pWDA->wdaStaInfo[staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3932 /* Reset framesTxed counters here */
3933 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3934 {
3935 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3936 }
3937 }
3938 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3939 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3940 return ;
3941}
3942
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3943/*
3944 * FUNCTION: WDA_ProcessDelBssReq
3945 * Init DEL BSS req with WDI
3946 */
3947VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3948 tDeleteBssParams *delBssParam)
3949{
3950 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3951 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3952 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3953 sizeof(WDI_DelBSSReqParamsType)) ;
3954 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3956 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3957 if(NULL == wdiDelBssReqParam)
3958 {
3959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3960 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3961 VOS_ASSERT(0);
3962 return VOS_STATUS_E_NOMEM;
3963 }
3964 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3965 if(NULL == pWdaParams)
3966 {
3967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3968 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3969 VOS_ASSERT(0);
3970 vos_mem_free(wdiDelBssReqParam);
3971 return VOS_STATUS_E_NOMEM;
3972 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3973 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3974 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3975
3976 /* Store Init Req pointer, as this will be used for response */
3977 /* store Params pass it to WDI */
3978 pWdaParams->pWdaContext = pWDA;
3979 pWdaParams->wdaMsgParam = delBssParam;
3980 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3981 status = WDI_DelBSSReq(wdiDelBssReqParam,
3982 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3983 if(IS_WDI_STATUS_FAILURE(status))
3984 {
3985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3986 "Failure in Del BSS WDI API, free all the memory " );
3987 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3988 vos_mem_free(pWdaParams) ;
3989 delBssParam->status = eSIR_FAILURE ;
3990 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3991 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3992 return CONVERT_WDI2VOS_STATUS(status) ;
3993}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3994/*
3995 * FUNCTION: WDA_DelSTAReqCallback
3996 * Dens DEL STA RSP back to PE
3997 */
3998void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3999 void* pUserData)
4000{
4001 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4002 tWDA_CbContext *pWDA;
4003 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4005 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4006 if(NULL == pWdaParams)
4007 {
4008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4009 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4010 VOS_ASSERT(0) ;
4011 return ;
4012 }
4013 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4014 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4015 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4016 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
4017 {
4018 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
4019 {
4020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4021 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4022 VOS_ASSERT(0) ;
4023 }
4024 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4025 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4026 }
4027 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4028 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4029 /*Reset the BA information corresponding to this STAIdx */
4030 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4031 WDA_INVALID_STA_INDEX;
4032 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4033 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4034 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4035 return ;
4036}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4037/*
4038 * FUNCTION: WDA_ProcessDelStaReq
4039 * Init DEL STA req with WDI
4040 */
4041VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4042 tDeleteStaParams *delStaParam)
4043{
4044 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4045 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4046 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4047 sizeof(WDI_DelSTAReqParamsType)) ;
4048 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4050 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4051 if(NULL == wdiDelStaReqParam)
4052 {
4053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4054 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4055 VOS_ASSERT(0);
4056 return VOS_STATUS_E_NOMEM;
4057 }
4058 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4059 if(NULL == pWdaParams)
4060 {
4061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4062 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4063 VOS_ASSERT(0);
4064 vos_mem_free(wdiDelStaReqParam);
4065 return VOS_STATUS_E_NOMEM;
4066 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4067 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
4068 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4069 /* Store Init Req pointer, as this will be used for response */
4070 /* store Params pass it to WDI */
4071 pWdaParams->pWdaContext = pWDA;
4072 pWdaParams->wdaMsgParam = delStaParam;
4073 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4074 status = WDI_DelSTAReq(wdiDelStaReqParam,
4075 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4076 if(IS_WDI_STATUS_FAILURE(status))
4077 {
4078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4079 "Failure in Del STA WDI API, free all the memory status = %d",
4080 status );
4081 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4082 vos_mem_free(pWdaParams) ;
4083 delStaParam->status = eSIR_FAILURE ;
4084 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4085 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4086 return CONVERT_WDI2VOS_STATUS(status) ;
4087}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4088void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
4089{
4090 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4091 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4092 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4094 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4095 if(NULL == pWdaParams)
4096 {
4097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4098 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4099 VOS_ASSERT(0) ;
4100 return ;
4101 }
4102 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4103 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4104 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4105 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4106 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4107 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4108 pwdiAddSTASelfRsp->macSelfSta,
4109 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4110 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4111 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4112 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4113 {
4114 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4115 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
4116 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4117 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4118 return ;
4119}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4120
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4121/*
4122 * FUNCTION: WDA_ProcessAddStaSelfReq
4123 *
4124 */
4125VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4126{
4127 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4128 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4129 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4130 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4131 sizeof(WDI_AddSTASelfReqParamsType)) ;
4132 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4134 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4135 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4136 if( NULL == wdiAddStaSelfReq )
4137 {
4138 VOS_ASSERT( 0 );
4139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4140 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4141 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4142 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4143 return( VOS_STATUS_E_NOMEM );
4144 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4145 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4146 if( NULL == pWdaParams )
4147 {
4148 VOS_ASSERT( 0 );
4149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4150 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4151 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4152 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4153 vos_mem_free(wdiAddStaSelfReq) ;
4154 return( VOS_STATUS_E_NOMEM );
4155 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4156 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4157 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4158 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159 /* Store Init Req pointer, as this will be used for response */
4160 /* store Params pass it to WDI */
4161 pWdaParams->pWdaContext = pWDA;
4162 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4163 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4164 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4165
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4166 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4167 {
4168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4169 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4170 wstatus );
4171 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4172 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4173 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4174 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4175 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4176 pAddStaSelfReq->status = eSIR_FAILURE ;
4177 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4178 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4179 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4180}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4181/*
4182 * FUNCTION: WDA_DelSTASelfRespCallback
4183 *
4184 */
4185void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4186 wdiDelStaSelfRspParams , void* pUserData)
4187{
4188 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4189 tWDA_CbContext *pWDA;
4190 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4192 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4193 if (NULL == pWdaParams)
4194 {
4195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4196 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4197 VOS_ASSERT(0);
4198 return;
4199 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4200 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4201 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4202 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4203 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4204
4205 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4206 vos_mem_free(pWdaParams) ;
4207
4208 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4209 return ;
4210}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4211/*
4212 * FUNCTION: WDA_DelSTASelfReqCallback
4213 *
4214 */
4215void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4216 void* pUserData)
4217{
4218 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4219 tWDA_CbContext *pWDA;
4220 tDelStaSelfParams *delStaSelfParams;
4221
4222 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4223 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4224 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4225
4226 if (NULL == pWdaParams)
4227 {
4228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4229 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4230 VOS_ASSERT(0);
4231 return;
4232 }
4233
4234 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4235 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4236
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4237 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4238
4239 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4240 {
4241 VOS_ASSERT(0);
4242 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4243 vos_mem_free(pWdaParams) ;
4244 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4245 }
4246
4247 return ;
4248}
4249
4250/*
4251 * FUNCTION: WDA_DelSTASelfReq
4252 * Trigger Config STA processing in WDI
4253 */
4254VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4255 tDelStaSelfParams* pDelStaSelfReqParam)
4256{
4257 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4258 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4259 tWDA_ReqParams *pWdaParams = NULL;
4260 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4261 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4262 sizeof(WDI_DelSTASelfReqParamsType)) ;
4263
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4265 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4266 if( NULL == wdiDelStaSelfReq )
4267 {
4268 VOS_ASSERT( 0 );
4269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4270 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4271 return( VOS_STATUS_E_NOMEM );
4272 }
4273
4274 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4275 if( NULL == pWdaParams )
4276 {
4277 VOS_ASSERT( 0 );
4278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4279 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4280 vos_mem_free(wdiDelStaSelfReq) ;
4281 return( VOS_STATUS_E_NOMEM );
4282 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4283 pWdaParams->pWdaContext = pWDA;
4284 /* Store param pointer as passed in by caller */
4285 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4286 /* store Params pass it to WDI */
4287 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4288 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4289 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4290
4291 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4292 wdiDelStaSelfReq->pUserData = pWdaParams;
4293
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4294 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4295 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4296
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4297 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4298 {
4299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4300 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4301 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4302 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4303 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4304 vos_mem_free(pWdaParams) ;
4305 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4306 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4307 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4308 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4309}
4310
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4311/*
4312 * FUNCTION: WDA_SendMsg
4313 * Send Message back to PE
4314 */
4315void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4316 void *pBodyptr, tANI_U32 bodyVal)
4317{
4318 tSirMsgQ msg = {0} ;
4319 tANI_U32 status = VOS_STATUS_SUCCESS ;
4320 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4321 msg.type = msgType;
4322 msg.bodyval = bodyVal;
4323 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4324 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4325 if (VOS_STATUS_SUCCESS != status)
4326 {
4327 if(NULL != pBodyptr)
4328 {
4329 vos_mem_free(pBodyptr);
4330 }
4331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4332 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4333 VOS_ASSERT(0) ;
4334 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4335 return ;
4336}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4337/*
4338 * FUNCTION: WDA_UpdateBSSParams
4339 * Translated WDA/PE BSS info into WDI BSS info..
4340 */
4341void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4342 WDI_ConfigBSSReqInfoType *wdiBssParams,
4343 tAddBssParams *wdaBssParams)
4344{
4345 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4346 /* copy bssReq Params to WDI structure */
4347 vos_mem_copy(wdiBssParams->macBSSID,
4348 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4349 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4350 sizeof(tSirMacAddr)) ;
4351 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4352 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4353 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4354 wdiBssParams->ucShortSlotTimeSupported =
4355 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4356 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4357 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4358 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4359 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4360 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4361
4362 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4363 wdiBssParams->ucTXOPProtectionFullSupport =
4364 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4365 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4366 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4367 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4368 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4369 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4370 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4371 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4372
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4373 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4374
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4375 /* copy SSID into WDI structure */
4376 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4377 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4378 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4379 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4380 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4381 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4382#ifdef WLAN_FEATURE_VOWIFI
4383 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4384#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4385 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4386 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4387#ifdef WLAN_FEATURE_VOWIFI_11R
4388 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4389 if(wdiBssParams->bExtSetStaKeyParamValid)
4390 {
4391 /* copy set STA key params to WDI structure */
4392 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4393 wdaBssParams->extSetStaKeyParam.staIdx;
4394 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4395 wdaBssParams->extSetStaKeyParam.encType;
4396 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4397 wdaBssParams->extSetStaKeyParam.wepType;
4398 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4399 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4400 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4401 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4402 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4403 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4404 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4405 {
4406 WDA_GetWepKeysFromCfg( pWDA,
4407 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4408 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4409 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4410 }
4411 else
4412 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4413 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4414 keyIndex++)
4415 {
4416 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4417 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4418 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4419 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4420 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4421 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4422 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4423 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4424 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4425 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4426 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4427 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4428 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4429 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4430 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4431 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4432 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4433 }
4434 }
4435 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4436 }
4437 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4438 {
4439 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4440 sizeof(wdaBssParams->extSetStaKeyParam) );
4441 }
4442#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4443#ifdef WLAN_FEATURE_11AC
4444 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4445 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4446#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4447
4448 return ;
4449}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4450/*
4451 * FUNCTION: WDA_UpdateSTAParams
4452 * Translated WDA/PE BSS info into WDI BSS info..
4453 */
4454void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4455 WDI_ConfigStaReqInfoType *wdiStaParams,
4456 tAddStaParams *wdaStaParams)
4457{
4458 tANI_U8 i = 0;
4459 /* Update STA params */
4460 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4461 sizeof(tSirMacAddr)) ;
4462 wdiStaParams->usAssocId = wdaStaParams->assocId;
4463 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4464 wdiStaParams->staIdx = wdaStaParams->staIdx;
4465
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4466 wdiStaParams->ucShortPreambleSupported =
4467 wdaStaParams->shortPreambleSupported;
4468 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4469 sizeof(tSirMacAddr)) ;
4470 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4471
4472 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4473
4474 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4475 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4476 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4477 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4478 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4479 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4480 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4481
4482 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4483 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4484 wdiStaParams->wdiSupportedRates.opRateMode =
4485 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4486 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4487 {
4488 wdiStaParams->wdiSupportedRates.llbRates[i] =
4489 wdaStaParams->supportedRates.llbRates[i];
4490 }
4491 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4492 {
4493 wdiStaParams->wdiSupportedRates.llaRates[i] =
4494 wdaStaParams->supportedRates.llaRates[i];
4495 }
4496 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4497 {
4498 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4499 wdaStaParams->supportedRates.aniLegacyRates[i];
4500 }
4501 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4502 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4503#ifdef WLAN_FEATURE_11AC
4504 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4505 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4506 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4507 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4508#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4509 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4510 {
4511 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4512 wdaStaParams->supportedRates.supportedMCSSet[i];
4513 }
4514 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4515 wdaStaParams->supportedRates.rxHighestDataRate;
4516
4517 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4518
4519 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4520
4521 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4522 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4523 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4524
4525 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4526 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4527 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4528 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4529 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4530#ifdef WLAN_FEATURE_11AC
4531 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4532 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4533 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4534 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4535 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4536 * must be set by default */
4537 if ( wdiStaParams->vhtTxMUBformeeCapable )
4538 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4539#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4540 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4541 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4542 return ;
4543}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4544/*
4545 * -------------------------------------------------------------------------
4546 * CFG update to WDI
4547 * -------------------------------------------------------------------------
4548 */
4549
4550 /*
4551 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4552 * Convert the WNI CFG ID to HAL CFG ID
4553 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4554static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4555{
4556 switch(wniCfgId)
4557 {
4558 case WNI_CFG_STA_ID:
4559 return QWLAN_HAL_CFG_STA_ID;
4560 case WNI_CFG_CURRENT_TX_ANTENNA:
4561 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4562 case WNI_CFG_CURRENT_RX_ANTENNA:
4563 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4564 case WNI_CFG_LOW_GAIN_OVERRIDE:
4565 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4566 case WNI_CFG_POWER_STATE_PER_CHAIN:
4567 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4568 case WNI_CFG_CAL_PERIOD:
4569 return QWLAN_HAL_CFG_CAL_PERIOD;
4570 case WNI_CFG_CAL_CONTROL:
4571 return QWLAN_HAL_CFG_CAL_CONTROL;
4572 case WNI_CFG_PROXIMITY:
4573 return QWLAN_HAL_CFG_PROXIMITY;
4574 case WNI_CFG_NETWORK_DENSITY:
4575 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4576 case WNI_CFG_MAX_MEDIUM_TIME:
4577 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4578 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4579 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4580 case WNI_CFG_RTS_THRESHOLD:
4581 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4582 case WNI_CFG_SHORT_RETRY_LIMIT:
4583 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4584 case WNI_CFG_LONG_RETRY_LIMIT:
4585 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4586 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4587 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4588 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4589 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4590 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4591 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4592 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4593 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4594 case WNI_CFG_FIXED_RATE:
4595 return QWLAN_HAL_CFG_FIXED_RATE;
4596 case WNI_CFG_RETRYRATE_POLICY:
4597 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4598 case WNI_CFG_RETRYRATE_SECONDARY:
4599 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4600 case WNI_CFG_RETRYRATE_TERTIARY:
4601 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4602 case WNI_CFG_FORCE_POLICY_PROTECTION:
4603 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4604 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4605 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4606 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4607 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4608 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4609 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4610 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4611 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4612 case WNI_CFG_MAX_BA_SESSIONS:
4613 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4614 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4615 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4616 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4617 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4618 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4619 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4620 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4621 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4622 case WNI_CFG_STATS_PERIOD:
4623 return QWLAN_HAL_CFG_STATS_PERIOD;
4624 case WNI_CFG_CFP_MAX_DURATION:
4625 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4626#if 0 /*This is not part of CFG*/
4627 case WNI_CFG_FRAME_TRANS_ENABLED:
4628 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4629#endif
4630 case WNI_CFG_DTIM_PERIOD:
4631 return QWLAN_HAL_CFG_DTIM_PERIOD;
4632 case WNI_CFG_EDCA_WME_ACBK:
4633 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4634 case WNI_CFG_EDCA_WME_ACBE:
4635 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4636 case WNI_CFG_EDCA_WME_ACVI:
4637 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4638 case WNI_CFG_EDCA_WME_ACVO:
4639 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4640#if 0
4641 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4642 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4643 case WNI_CFG_TELE_BCN_TRANS_LI:
4644 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4645 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4646 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4647 case WNI_CFG_TELE_BCN_MAX_LI:
4648 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4649 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4650 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4651#endif
4652 case WNI_CFG_ENABLE_CLOSE_LOOP:
4653 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4654 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4655 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4656 default:
4657 {
4658 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4659 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4660 wniCfgId);
4661 return VOS_STATUS_E_INVAL;
4662 }
4663 }
4664}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4665/*
4666 * FUNCTION: WDA_UpdateCfgCallback
4667 *
4668 */
4669void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4670{
4671 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4672 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4673 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4675 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4676 /*
4677 * currently there is no response message is expected between PE and
4678 * WDA, Failure return from WDI is a ASSERT condition
4679 */
4680 if(WDI_STATUS_SUCCESS != wdiStatus)
4681 {
4682 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4683 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4684 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4685 }
4686
4687 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4688 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4689 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4690 return ;
4691}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4692/*
4693 * FUNCTION: WDA_UpdateCfg
4694 *
4695 */
4696VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4697{
4698
4699 WDI_Status status = WDI_STATUS_SUCCESS ;
4700 tANI_U32 val =0;
4701 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4702 tHalCfg *configData;
4703 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4704 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4706 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4707 if (NULL == pMac )
4708 {
4709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4710 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4711 return VOS_STATUS_E_FAILURE;
4712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4713 if(WDA_START_STATE != pWDA->wdaState)
4714 {
4715 return VOS_STATUS_E_FAILURE;
4716 }
4717
4718 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4719 {
4720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4721 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4722 VOS_ASSERT(0);
4723 return VOS_STATUS_E_FAILURE;
4724 }
4725
4726 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4727 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4728 if(NULL == wdiCfgReqParam)
4729 {
4730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4731 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4732 VOS_ASSERT(0);
4733 return VOS_STATUS_E_NOMEM;
4734 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4735 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4736 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4737 if(NULL == wdiCfgReqParam->pConfigBuffer)
4738 {
4739 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4740 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4741 vos_mem_free(wdiCfgReqParam);
4742 VOS_ASSERT(0);
4743 return VOS_STATUS_E_NOMEM;
4744 }
4745
4746 /*convert the WNI CFG Id to HAL CFG Id*/
4747 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4748 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4749
4750 /*TODO: revisit this for handling string parameters */
4751 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4752 &val) != eSIR_SUCCESS)
4753 {
4754 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4755 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4756 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4757 vos_mem_free(wdiCfgReqParam);
4758 return eSIR_FAILURE;
4759 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4760 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4761 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4762 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4763 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4764 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4765
4766 /* store Params pass it to WDI */
4767 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4768#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4769 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4770 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4771 if(IS_WDI_STATUS_FAILURE(status))
4772 {
4773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4774 "Failure in Update CFG WDI API, free all the memory " );
4775 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4776 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4777 pWDA->wdaWdiCfgApiMsgParam = NULL;
4778 /* Failure is not expected */
4779 VOS_ASSERT(0) ;
4780 }
4781#else
4782 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4783 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4784 pWDA->wdaWdiCfgApiMsgParam = NULL;
4785#endif
4786 return CONVERT_WDI2VOS_STATUS(status) ;
4787}
4788
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4789VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4790 v_U8_t *pDefaultKeyId,
4791 v_U8_t *pNumKeys,
4792 WDI_KeysType *pWdiKeys )
4793{
4794 v_U32_t i, j, defKeyId = 0;
4795 v_U32_t val = SIR_MAC_KEY_LENGTH;
4796 VOS_STATUS status = WDI_STATUS_SUCCESS;
4797 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4798 if (NULL == pMac )
4799 {
4800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4801 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4802 return VOS_STATUS_E_FAILURE;
4803 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4804 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4805 &defKeyId ))
4806 {
4807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4808 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4809 }
4810
4811 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4812 /* Need to extract ALL of the configured WEP Keys */
4813 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4814 {
4815 val = SIR_MAC_KEY_LENGTH;
4816 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4817 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4818 pWdiKeys[j].key,
4819 &val ))
4820 {
4821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4822 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4823 }
4824 else
4825 {
4826 pWdiKeys[j].keyId = (tANI_U8) i;
4827 /*
4828 * Actually, a DC (Don't Care) because
4829 * this is determined (and set) by PE/MLME
4830 */
4831 pWdiKeys[j].unicast = 0;
4832 /*
4833 * Another DC (Don't Care)
4834 */
4835 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4836 /* Another DC (Don't Care). Unused for WEP */
4837 pWdiKeys[j].paeRole = 0;
4838 /* Determined from wlan_cfgGetStr() above.*/
4839 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4840 j++;
4841 *pNumKeys = (tANI_U8) j;
4842 }
4843 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4844 return status;
4845}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4846/*
4847 * FUNCTION: WDA_SetBssKeyReqCallback
4848 * send SET BSS key RSP back to PE
4849 */
4850void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4851{
4852 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4853 tWDA_CbContext *pWDA;
4854 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4856 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4857 if(NULL == pWdaParams)
4858 {
4859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4860 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4861 VOS_ASSERT(0) ;
4862 return ;
4863 }
4864 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4865 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4866 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4867 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4868 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4869 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4870 return ;
4871}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4872/*
4873 * FUNCTION: WDA_ProcessSetBssKeyReq
4874 * Request to WDI for programming the BSS key( key for
4875 * broadcast/multicast frames Encryption)
4876 */
4877VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4878 tSetBssKeyParams *setBssKeyParams )
4879{
4880 WDI_Status status = WDI_STATUS_SUCCESS ;
4881 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4882 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4883 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4884 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4885 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4887 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4888 if(NULL == wdiSetBssKeyParam)
4889 {
4890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4891 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4892 VOS_ASSERT(0);
4893 return VOS_STATUS_E_NOMEM;
4894 }
4895 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4896 if(NULL == pWdaParams)
4897 {
4898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4899 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4900 VOS_ASSERT(0);
4901 vos_mem_free(wdiSetBssKeyParam);
4902 return VOS_STATUS_E_NOMEM;
4903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4904 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4905 /* copy set BSS params to WDI structure */
4906 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4907 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4908 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4909 if(setBssKeyParams->encType != eSIR_ED_NONE)
4910 {
4911 if( setBssKeyParams->numKeys == 0 &&
4912 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4913 setBssKeyParams->encType == eSIR_ED_WEP104))
4914 {
4915 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4916 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4917 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4918 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4919 }
4920 else
4921 {
4922 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4923 {
4924 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4925 setBssKeyParams->key[keyIndex].keyId;
4926 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4927 setBssKeyParams->key[keyIndex].unicast;
4928 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4929 setBssKeyParams->key[keyIndex].keyDirection;
4930 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4931 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4932 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4933 setBssKeyParams->key[keyIndex].paeRole;
4934 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4935 setBssKeyParams->key[keyIndex].keyLength;
4936 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4937 setBssKeyParams->key[keyIndex].key,
4938 SIR_MAC_MAX_KEY_LENGTH);
4939 }
4940 }
4941 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4942 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4943 setBssKeyParams->singleTidRc;
4944 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4945 /* Store set key pointer, as this will be used for response */
4946 /* store Params pass it to WDI */
4947 pWdaParams->pWdaContext = pWDA;
4948 pWdaParams->wdaMsgParam = setBssKeyParams;
4949 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4950 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4951 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4952
4953 if(IS_WDI_STATUS_FAILURE(status))
4954 {
4955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4956 "Failure in Set BSS Key Req WDI API, free all the memory " );
4957 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4958 vos_mem_free(pWdaParams) ;
4959 setBssKeyParams->status = eSIR_FAILURE ;
4960 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4961 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4962 return CONVERT_WDI2VOS_STATUS(status) ;
4963}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4964/*
4965 * FUNCTION: WDA_RemoveBssKeyReqCallback
4966 * send SET BSS key RSP back to PE
4967 */
4968void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4969{
4970 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4971 tWDA_CbContext *pWDA;
4972 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4974 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4975 if(NULL == pWdaParams)
4976 {
4977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4978 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4979 VOS_ASSERT(0) ;
4980 return ;
4981 }
4982 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4983 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4984 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4985 vos_mem_free(pWdaParams) ;
4986
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4987 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4988 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4989 return ;
4990}
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]4991
4992/*
4993 * FUNCTION: WDA_SpoofMacAddrRspCallback
4994 * recieves spoof mac addr response from FW
4995 */
4996void WDA_SpoofMacAddrRspCallback(WDI_SpoofMacAddrRspParamType* wdiRsp, void* pUserData)
4997{
4998 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4999 tWDA_CbContext *pWDA;
5000 tSirSpoofMacAddrReq *spoofMacAddrReq;
5001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5002 "<------ %s " ,__func__);
5003 if(NULL == pWdaParams)
5004 {
5005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5006 "%s: pWdaParams received NULL", __func__);
5007 VOS_ASSERT(0) ;
5008 return ;
5009 }
5010
5011 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5012 spoofMacAddrReq = (tSirSpoofMacAddrReq *)pWdaParams->wdaMsgParam ;
5013
5014 if(wdiRsp->wdiStatus != WDI_STATUS_SUCCESS )
5015 {
5016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5017 "%s: Unable to set Random Mac Addr in FW", __func__);
5018 }
5019
5020 vos_mem_free(spoofMacAddrReq);
5021 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5022 vos_mem_free(pWdaParams);
5023 return ;
5024}
5025
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5026/*
5027 * FUNCTION: WDA_ProcessRemoveBssKeyReq
5028 * Request to WDI to remove the BSS key( key for broadcast/multicast
5029 * frames Encryption)
5030 */
5031VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
5032 tRemoveBssKeyParams *removeBssKeyParams )
5033{
5034 WDI_Status status = WDI_STATUS_SUCCESS ;
5035 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
5036 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
5037 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
5038 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5040 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5041 if(NULL == wdiRemoveBssKeyParam)
5042 {
5043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5044 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5045 VOS_ASSERT(0);
5046 return VOS_STATUS_E_NOMEM;
5047 }
5048 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5049 if(NULL == pWdaParams)
5050 {
5051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5052 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5053 VOS_ASSERT(0);
5054 vos_mem_free(wdiRemoveBssKeyParam);
5055 return VOS_STATUS_E_NOMEM;
5056 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5057 /* copy Remove BSS key params to WDI structure*/
5058 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5059 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5060 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5061 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5062 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5063 /* Store remove key pointer, as this will be used for response */
5064 /* store Params pass it to WDI */
5065 pWdaParams->pWdaContext = pWDA;
5066 pWdaParams->wdaMsgParam = removeBssKeyParams;
5067 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5068 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5069 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5070 if(IS_WDI_STATUS_FAILURE(status))
5071 {
5072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5073 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5074 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5075 vos_mem_free(pWdaParams) ;
5076 removeBssKeyParams->status = eSIR_FAILURE ;
5077 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5078 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5079 return CONVERT_WDI2VOS_STATUS(status) ;
5080}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5081/*
5082 * FUNCTION: WDA_SetBssKeyReqCallback
5083 * send SET BSS key RSP back to PE
5084 */
5085void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5086{
5087 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5088 tWDA_CbContext *pWDA;
5089 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5091 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5092 if(NULL == pWdaParams)
5093 {
5094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5095 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5096 VOS_ASSERT(0) ;
5097 return ;
5098 }
5099 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5100 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5101 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5102 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5103 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5104 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5105 return ;
5106}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5107/*
5108 * FUNCTION: WDA_ProcessSetStaKeyReq
5109 * Request to WDI for programming the STA key( key for Unicast frames
5110 * Encryption)
5111 */
5112VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5113 tSetStaKeyParams *setStaKeyParams )
5114{
5115 WDI_Status status = WDI_STATUS_SUCCESS ;
5116 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5117 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5118 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5119 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5120 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5122 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5123 if(NULL == wdiSetStaKeyParam)
5124 {
5125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5126 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5127 VOS_ASSERT(0);
5128 return VOS_STATUS_E_NOMEM;
5129 }
5130 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5131 if(NULL == pWdaParams)
5132 {
5133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5134 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5135 VOS_ASSERT(0);
5136 vos_mem_free(wdiSetStaKeyParam);
5137 return VOS_STATUS_E_NOMEM;
5138 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5139 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5140 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5141 /* copy set STA key params to WDI structure */
5142 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5143 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5144 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5145 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5146 if(setStaKeyParams->encType != eSIR_ED_NONE)
5147 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5148 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5149 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5150 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5151 {
5152 WDA_GetWepKeysFromCfg( pWDA,
5153 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5154 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5155 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5156 }
5157 else
5158 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5159 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5160 keyIndex++)
5161 {
5162 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5163 setStaKeyParams->key[keyIndex].keyId;
5164 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5165 setStaKeyParams->key[keyIndex].unicast;
5166 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5167 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5168 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5169 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5170 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5171 setStaKeyParams->key[keyIndex].paeRole;
5172 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5173 setStaKeyParams->key[keyIndex].keyLength;
5174 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5175 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5176 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5177 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5178 {
5179 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5180 }
5181 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5182 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5183 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5184 }
5185 }
5186 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5187 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5188 /* Store set key pointer, as this will be used for response */
5189 /* store Params pass it to WDI */
5190 pWdaParams->pWdaContext = pWDA;
5191 pWdaParams->wdaMsgParam = setStaKeyParams;
5192 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5193 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5194 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5195 if(IS_WDI_STATUS_FAILURE(status))
5196 {
5197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5198 "Failure in set STA Key Req WDI API, free all the memory " );
5199 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5200 vos_mem_free(pWdaParams) ;
5201 setStaKeyParams->status = eSIR_FAILURE ;
5202 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5203 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5204 return CONVERT_WDI2VOS_STATUS(status) ;
5205}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5206/*
5207 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5208 * send SET Bcast STA key RSP back to PE
5209 */
5210void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5211{
5212 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5213 tWDA_CbContext *pWDA;
5214 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5216 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5217 if(NULL == pWdaParams)
5218 {
5219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5220 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5221 VOS_ASSERT(0) ;
5222 return ;
5223 }
5224 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5225 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5226 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5227 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5228 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5229 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5230 return ;
5231}
5232
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5233/*
5234 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5235 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5236 * Encryption)
5237 */
5238VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5239 tSetStaKeyParams *setStaKeyParams )
5240{
5241 WDI_Status status = WDI_STATUS_SUCCESS ;
5242 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5243 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5244 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5245 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5246 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5248 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5249 if(NULL == wdiSetStaKeyParam)
5250 {
5251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5252 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5253 VOS_ASSERT(0);
5254 return VOS_STATUS_E_NOMEM;
5255 }
5256 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5257 if(NULL == pWdaParams)
5258 {
5259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5260 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5261 VOS_ASSERT(0);
5262 vos_mem_free(wdiSetStaKeyParam);
5263 return VOS_STATUS_E_NOMEM;
5264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5265 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5266 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5267 /* copy set STA key params to WDI structure */
5268 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5269 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5270 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5271 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5272 if(setStaKeyParams->encType != eSIR_ED_NONE)
5273 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5274 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5275 keyIndex++)
5276 {
5277 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5278 setStaKeyParams->key[keyIndex].keyId;
5279 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5280 setStaKeyParams->key[keyIndex].unicast;
5281 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5282 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5283 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5284 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5285 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5286 setStaKeyParams->key[keyIndex].paeRole;
5287 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5288 setStaKeyParams->key[keyIndex].keyLength;
5289 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5290 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5291 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5292 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5293 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5294 }
5295 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5296 /* Store set key pointer, as this will be used for response */
5297 /* store Params pass it to WDI */
5298 pWdaParams->pWdaContext = pWDA;
5299 pWdaParams->wdaMsgParam = setStaKeyParams;
5300 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5301 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5302 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303 if(IS_WDI_STATUS_FAILURE(status))
5304 {
5305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5306 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5307 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5308 vos_mem_free(pWdaParams) ;
5309 setStaKeyParams->status = eSIR_FAILURE ;
5310 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5311 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5312 return CONVERT_WDI2VOS_STATUS(status) ;
5313}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5314/*
5315 * FUNCTION: WDA_RemoveStaKeyReqCallback
5316 * send SET BSS key RSP back to PE
5317 */
5318void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5319{
5320 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5321 tWDA_CbContext *pWDA;
5322 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]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 == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5329 VOS_ASSERT(0) ;
5330 return ;
5331 }
5332 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5333 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5334 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5335 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5336 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5337 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5338 return ;
5339}
5340
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5341/*
5342 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5343 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5344 */
5345VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5346 tRemoveStaKeyParams *removeStaKeyParams )
5347{
5348 WDI_Status status = WDI_STATUS_SUCCESS ;
5349 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5350 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5351 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5352 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5354 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5355 if(NULL == wdiRemoveStaKeyParam)
5356 {
5357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5358 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5359 VOS_ASSERT(0);
5360 return VOS_STATUS_E_NOMEM;
5361 }
5362 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5363 if(NULL == pWdaParams)
5364 {
5365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5366 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5367 VOS_ASSERT(0);
5368 vos_mem_free(wdiRemoveStaKeyParam);
5369 return VOS_STATUS_E_NOMEM;
5370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5371 /* copy remove STA key params to WDI structure*/
5372 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5373 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5374 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5375 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5376 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5377 /* Store remove key pointer, as this will be used for response */
5378 /* store Params pass it to WDI */
5379 pWdaParams->pWdaContext = pWDA;
5380 pWdaParams->wdaMsgParam = removeStaKeyParams;
5381 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5382 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5383 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5384 if(IS_WDI_STATUS_FAILURE(status))
5385 {
5386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5387 "Failure in remove STA Key Req WDI API, free all the memory " );
5388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5389 vos_mem_free(pWdaParams) ;
5390 removeStaKeyParams->status = eSIR_FAILURE ;
5391 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5392 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5393 return CONVERT_WDI2VOS_STATUS(status) ;
5394}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5395/*
5396 * FUNCTION: WDA_IsHandleSetLinkStateReq
5397 * Update the WDA state and return the status to handle this message or not
5398 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5399WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5400 tWDA_CbContext *pWDA,
5401 tLinkStateParams *linkStateParams)
5402{
5403 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5404 switch(linkStateParams->state)
5405 {
5406 case eSIR_LINK_PREASSOC_STATE:
5407 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5408 /*
5409 * set the WDA state to PRE ASSOC
5410 * copy the BSSID into pWDA to use it in join request and return,
5411 * No need to handle these messages.
5412 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5413 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5414 {
5415 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5416 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5417 }
5418 else
5419 {
5420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5421 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5422 VOS_ASSERT(0);
5423 }
5424
5425 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5426 {
5427 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5428 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5429 }
5430 else
5431 {
5432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5433 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5434 VOS_ASSERT(0);
5435 }
5436
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5437 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5438 *channel and after ) so reset the WDA state to ready when the second
5439 * time UMAC issue the link state with PREASSOC
5440 */
5441 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5442 {
5443 /* RESET WDA state back to WDA_READY_STATE */
5444 pWDA->wdaState = WDA_READY_STATE;
5445 }
5446 else
5447 {
5448 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5449 }
5450 //populate linkState info in WDACbCtxt
5451 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5452 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5453 default:
5454 if(pWDA->wdaState != WDA_READY_STATE)
5455 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5456 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5457 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5458 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5459 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5460 *the ASSERT in WDA_Stop during module unload.*/
5461 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5462 {
5463 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5464 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5465 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5466 else
5467 {
5468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5469 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5470 status = WDA_IGNORE_SET_LINK_STATE;
5471 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5472 }
5473 break;
5474 }
5475
5476 return status;
5477}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5478/*
5479 * FUNCTION: WDA_SetLinkStateCallback
5480 * call back function for set link state from WDI
5481 */
5482void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5483{
5484 tWDA_CbContext *pWDA;
5485 tLinkStateParams *linkStateParams;
5486 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5488 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5489 if(NULL == pWdaParams)
5490 {
5491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5492 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5493 VOS_ASSERT(0) ;
5494 return ;
5495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5496 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5497 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5498 /*
5499 * In STA mode start the BA activity check timer after association
5500 * and in AP mode start BA activity check timer after BSS start */
5501 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5502 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5503 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5504 ((status == WDI_STATUS_SUCCESS) &&
5505 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5506 {
5507 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5508 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5509 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5510 /*
5511 * No respone required for WDA_SET_LINK_STATE so free the request
5512 * param here
5513 */
5514 if( pWdaParams != NULL )
5515 {
5516 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5517 {
5518 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5519 }
5520 vos_mem_free(pWdaParams);
5521 }
5522 return ;
5523}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5524/*
5525 * FUNCTION: WDA_ProcessSetLinkState
5526 * Request to WDI to set the link status.
5527 */
5528VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5529 tLinkStateParams *linkStateParams)
5530{
5531 WDI_Status status = WDI_STATUS_SUCCESS ;
5532 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5533 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5534 sizeof(WDI_SetLinkReqParamsType)) ;
5535 tWDA_ReqParams *pWdaParams ;
5536 tpAniSirGlobal pMac;
5537 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5538
5539 if(NULL == pMac)
5540 {
5541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5542 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5543 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5544 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5545 return VOS_STATUS_E_FAILURE;
5546 }
5547
5548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5549 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5550 if(NULL == wdiSetLinkStateParam)
5551 {
5552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5553 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5554 VOS_ASSERT(0);
5555 return VOS_STATUS_E_NOMEM;
5556 }
5557 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5558 if(NULL == pWdaParams)
5559 {
5560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5561 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5562 VOS_ASSERT(0);
5563 vos_mem_free(wdiSetLinkStateParam);
5564 return VOS_STATUS_E_NOMEM;
5565 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5566 if(WDA_IGNORE_SET_LINK_STATE ==
5567 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5568 {
5569 status = WDI_STATUS_E_FAILURE;
5570 }
5571 else
5572 {
5573 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5574 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5575 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5576 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5577 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5578 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5579 pWdaParams->pWdaContext = pWDA;
5580 /* Store remove key pointer, as this will be used for response */
5581 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5582 /* store Params pass it to WDI */
5583 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5584 /* Stop Timer only other than GO role and concurrent session */
5585 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5586 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5587 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5588 {
5589 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5590 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5591 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5592 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5593 if(IS_WDI_STATUS_FAILURE(status))
5594 {
5595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5596 "Failure in set link state Req WDI API, free all the memory " );
5597 }
5598 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5599 if(IS_WDI_STATUS_FAILURE(status))
5600 {
5601 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5602 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5603 vos_mem_free(pWdaParams);
5604 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5605 return CONVERT_WDI2VOS_STATUS(status) ;
5606}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5607/*
5608 * FUNCTION: WDA_GetStatsReqParamsCallback
5609 * send the response to PE with Stats received from WDI
5610 */
5611void WDA_GetStatsReqParamsCallback(
5612 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5613 void* pUserData)
5614{
5615 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5616 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5617
5618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5619 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5620 pGetPEStatsRspParams =
5621 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5622 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5623
5624 if(NULL == pGetPEStatsRspParams)
5625 {
5626 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5627 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5628 VOS_ASSERT(0);
5629 return;
5630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5631 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5632 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5633 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5634 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5635
5636 //Fill the Session Id Properly in PE
5637 pGetPEStatsRspParams->sessionId = 0;
5638 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5639 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5640 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5641 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5642 vos_mem_copy( pGetPEStatsRspParams + 1,
5643 wdiGetStatsRsp + 1,
5644 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5645 /* send response to UMAC*/
5646 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5647
5648 return;
5649}
5650
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5651/*
5652 * FUNCTION: WDA_ProcessGetStatsReq
5653 * Request to WDI to get the statistics
5654 */
5655VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5656 tAniGetPEStatsReq *pGetStatsParams)
5657{
5658 WDI_Status status = WDI_STATUS_SUCCESS ;
5659 WDI_GetStatsReqParamsType wdiGetStatsParam;
5660 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5662 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5663 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5664 pGetStatsParams->staId;
5665 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5666 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5667 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5668 status = WDI_GetStatsReq(&wdiGetStatsParam,
5669 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5670 if(IS_WDI_STATUS_FAILURE(status))
5671 {
5672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5673 "Failure in Get Stats Req WDI API, free all the memory " );
5674 pGetPEStatsRspParams =
5675 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5676 if(NULL == pGetPEStatsRspParams)
5677 {
5678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5679 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5680 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5681 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5682 return VOS_STATUS_E_NOMEM;
5683 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5684 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5685 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5686 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5687 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5688 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5689 (void *)pGetPEStatsRspParams, 0) ;
5690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5691 /* Free the request message */
5692 vos_mem_free(pGetStatsParams);
5693 return CONVERT_WDI2VOS_STATUS(status);
5694}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5695
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5696#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5697/*
5698 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5699 * send the response to PE with roam Rssi received from WDI
5700 */
5701void WDA_GetRoamRssiReqParamsCallback(
5702 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5703 void* pUserData)
5704{
5705 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5706 tWDA_CbContext *pWDA = NULL;
5707 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5708 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5710 "<------ %s " ,__func__);
5711 if(NULL == pWdaParams)
5712 {
5713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5714 "%s: pWdaParams received NULL", __func__);
5715 VOS_ASSERT(0) ;
5716 return ;
5717 }
5718 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5719 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5720
5721 if(NULL == pGetRoamRssiReqParams)
5722 {
5723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5724 "%s: pGetRoamRssiReqParams received NULL", __func__);
5725 VOS_ASSERT(0);
5726 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5727 vos_mem_free(pWdaParams);
5728 return ;
5729 }
5730 pGetRoamRssiRspParams =
5731 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5732
5733 if(NULL == pGetRoamRssiRspParams)
5734 {
5735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5736 "%s: VOS MEM Alloc Failure", __func__);
5737 VOS_ASSERT(0);
5738 return;
5739 }
5740 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5741 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5742 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5743 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5744 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5745
5746 /* Assign get roam rssi req (backup) in to the response */
5747 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5748
5749 /* free WDI command buffer */
5750 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5751 vos_mem_free(pWdaParams) ;
5752
5753 /* send response to UMAC*/
5754 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5755
5756 return;
5757}
5758
5759
5760
5761/*
5762 * FUNCTION: WDA_ProcessGetRoamRssiReq
5763 * Request to WDI to get the statistics
5764 */
5765VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5766 tAniGetRssiReq *pGetRoamRssiParams)
5767{
5768 WDI_Status status = WDI_STATUS_SUCCESS ;
5769 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5770 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5771 tWDA_ReqParams *pWdaParams = NULL;
5772
5773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5774 "------> %s " ,__func__);
5775 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5776 pGetRoamRssiParams->staId;
5777 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5778
5779 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5780 if(NULL == pWdaParams)
5781 {
5782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5783 "%s: VOS MEM Alloc Failure", __func__);
5784 VOS_ASSERT(0);
5785 return VOS_STATUS_E_NOMEM;
5786 }
5787
5788 /* Store Init Req pointer, as this will be used for response */
5789 pWdaParams->pWdaContext = pWDA;
5790
5791 /* Take Get roam Rssi req backup as it stores the callback to be called after
5792 receiving the response */
5793 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5794 pWdaParams->wdaWdiApiMsgParam = NULL;
5795
5796 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5797 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5798 if(IS_WDI_STATUS_FAILURE(status))
5799 {
5800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5801 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5802 pGetRoamRssiRspParams =
5803 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5804 if(NULL == pGetRoamRssiRspParams)
5805 {
5806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5807 "%s: VOS MEM Alloc Failure", __func__);
5808 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5809 vos_mem_free(pGetRoamRssiParams);
5810 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5811 return VOS_STATUS_E_NOMEM;
5812 }
5813 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5814 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5815 pGetRoamRssiRspParams->rssi = 0;
5816 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5817 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5818 (void *)pGetRoamRssiRspParams, 0) ;
5819 }
5820 return CONVERT_WDI2VOS_STATUS(status);
5821}
5822#endif
5823
5824
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5825/*
5826 * FUNCTION: WDA_UpdateEDCAParamCallback
5827 * call back function for Update EDCA params from WDI
5828 */
5829void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5830{
5831 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5832 tEdcaParams *pEdcaParams;
5833
5834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5835 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5836 if(NULL == pWdaParams)
5837 {
5838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5839 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5840 VOS_ASSERT(0) ;
5841 return ;
5842 }
5843 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5844 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5845 vos_mem_free(pWdaParams);
5846 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5847 return ;
5848}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5849/*
5850 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5851 * Request to WDI to Update the EDCA params.
5852 */
5853VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5854 tEdcaParams *pEdcaParams)
5855{
5856 WDI_Status status = WDI_STATUS_SUCCESS ;
5857 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5858 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5859 sizeof(WDI_UpdateEDCAParamsType)) ;
5860 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5862 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5863 if(NULL == wdiEdcaParam)
5864 {
5865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5866 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5867 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5868 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5869 return VOS_STATUS_E_NOMEM;
5870 }
5871 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5872 if(NULL == pWdaParams)
5873 {
5874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5875 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5876 VOS_ASSERT(0);
5877 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5878 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5879 return VOS_STATUS_E_NOMEM;
5880 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5881 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5882 /*
5883 Since firmware is not using highperformance flag, we have removed
5884 this flag from wdiEDCAInfo structure to match sizeof the structure
5885 between host and firmware.In future if we are planning to use
5886 highperformance flag then Please define this flag in wdiEDCAInfo
5887 structure, update it here and send it to firmware. i.e.
5888 Following is the original line which we removed as part of the fix
5889 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5890 pEdcaParams->highPerformance;
5891 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5892 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5893 &pEdcaParams->acbe);
5894 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5895 &pEdcaParams->acbk);
5896 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5897 &pEdcaParams->acvi);
5898 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5899 &pEdcaParams->acvo);
5900 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5901 pWdaParams->pWdaContext = pWDA;
5902 /* Store remove key pointer, as this will be used for response */
5903 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5904 /* store Params pass it to WDI */
5905 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5906 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5907 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5908 if(IS_WDI_STATUS_FAILURE(status))
5909 {
5910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5911 "Failure in Update EDCA Params WDI API, free all the memory " );
5912 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5913 vos_mem_free(pWdaParams);
5914 vos_mem_free(pEdcaParams);
5915 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 return CONVERT_WDI2VOS_STATUS(status) ;
5917}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5918/*
5919 * FUNCTION: WDA_AddBAReqCallback
5920 * send ADD BA RSP back to PE
5921 */
5922void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5923 void* pUserData)
5924{
5925 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5926 tWDA_CbContext *pWDA;
5927 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5929 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5930 if(NULL == pWdaParams)
5931 {
5932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5933 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5934 VOS_ASSERT(0) ;
5935 return ;
5936 }
5937 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5938 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5939 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5940 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5941 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5942 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5943 return ;
5944}
5945
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946/*
5947 * FUNCTION: WDA_ProcessAddBAReq
5948 * Request to WDI to Update the ADDBA REQ params.
5949 */
5950VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5951 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5952{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5953 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5954 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5955 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5956 sizeof(WDI_AddBAReqParamsType)) ;
5957 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5959 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5960 if(NULL == wdiAddBAReqParam)
5961 {
5962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5963 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5964 VOS_ASSERT(0);
5965 return VOS_STATUS_E_NOMEM;
5966 }
5967 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5968 if(NULL == pWdaParams)
5969 {
5970 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5971 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5972 VOS_ASSERT(0);
5973 vos_mem_free(wdiAddBAReqParam);
5974 return VOS_STATUS_E_NOMEM;
5975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5976 do
5977 {
5978 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5979 wdiAddBaInfo->ucSTAIdx = staIdx ;
5980 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5981 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5982 } while(0) ;
5983 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5984 pWdaParams->pWdaContext = pWDA;
5985 /* store Params pass it to WDI */
5986 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5987 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5988 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5989 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5990
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5991 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5992 {
5993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5994 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5995 status = CONVERT_WDI2VOS_STATUS(wstatus);
5996 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5997 vos_mem_free(pWdaParams);
5998 pAddBAReqParams->status = eSIR_FAILURE;
5999 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6000 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6001 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6002}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6003/*
6004 * FUNCTION: WDA_AddBASessionReqCallback
6005 * send ADD BA SESSION RSP back to PE/(or TL)
6006 */
6007void WDA_AddBASessionReqCallback(
6008 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
6009{
6010 VOS_STATUS status = VOS_STATUS_SUCCESS ;
6011 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6012 tWDA_CbContext *pWDA;
6013 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6015 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6016 if(NULL == pWdaParams)
6017 {
6018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6019 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6020 VOS_ASSERT(0) ;
6021 return ;
6022 }
6023 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6024 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6025 if( NULL == pAddBAReqParams )
6026 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6028 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6029 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6030 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6031 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6032 return ;
6033 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6034 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6035 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6036 /*
6037 * if WDA in update TL state, update TL with BA session parama and send
6038 * another request to HAL(/WDI) (ADD_BA_REQ)
6039 */
6040
6041 if((VOS_STATUS_SUCCESS ==
6042 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
6043 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
6044 {
6045 /* Update TL with BA info received from HAL/WDI */
6046 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
6047 wdiAddBaSession->usBaSessionID,
6048 wdiAddBaSession->ucSTAIdx,
6049 wdiAddBaSession->ucBaTID,
6050 wdiAddBaSession->ucBaBufferSize,
6051 wdiAddBaSession->ucWinSize,
6052 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6053 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
6054 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
6055 }
6056 else
6057 {
6058 pAddBAReqParams->status =
6059 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6060
6061 /* Setting Flag to indicate that Set BA is success */
6062 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6063 {
6064 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6065 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6066 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6067 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6068 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6069 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6070 /*Reset the WDA state to READY */
6071 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072 return ;
6073}
6074
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6075/*
6076 * FUNCTION: WDA_ProcessAddBASessionReq
6077 * Request to WDI to Update the ADDBA REQ params.
6078 */
6079VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6080 tAddBAParams *pAddBAReqParams)
6081{
6082 WDI_Status status = WDI_STATUS_SUCCESS ;
6083 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6084 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6085 sizeof(WDI_AddBASessionReqParamsType)) ;
6086 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6087 WLANTL_STAStateType tlSTAState = 0;
6088
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6090 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6091 if(NULL == wdiAddBASessionReqParam)
6092 {
6093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6094 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6095 VOS_ASSERT(0);
6096 return VOS_STATUS_E_NOMEM;
6097 }
6098 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6099 if(NULL == pWdaParams)
6100 {
6101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6102 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6103 VOS_ASSERT(0);
6104 vos_mem_free(wdiAddBASessionReqParam);
6105 return VOS_STATUS_E_NOMEM;
6106 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6107 /*
6108 * Populate ADD BA parameters and pass these paarmeters to WDI.
6109 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6110 * the state to track if these is BA recipient case or BA initiator
6111 * case.
6112 */
6113 do
6114 {
6115 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6116 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6117 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6118 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6119 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6120 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6121 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6122 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6123 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6124 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6125 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6126 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6127 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6128 /* check the BA direction and update state accordingly */
6129 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
6130 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
6131 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
6132
6133 }while(0) ;
6134 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6135 pWdaParams->pWdaContext = pWDA;
6136 /* Store ADD BA pointer, as this will be used for response */
6137 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6138 /* store Params pass it to WDI */
6139 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6140
6141 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6142 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6143 */
6144 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6145 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6146 {
6147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6148 "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]6149 status = WDI_STATUS_E_NOT_ALLOWED;
6150 pAddBAReqParams->status =
6151 CONVERT_WDI2SIR_STATUS(status) ;
6152 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6153 /*Reset the WDA state to READY */
6154 pWDA->wdaState = WDA_READY_STATE;
6155 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6156 vos_mem_free(pWdaParams);
6157
6158 return CONVERT_WDI2VOS_STATUS(status) ;
6159 }
6160
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6161 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6162 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6163 if(IS_WDI_STATUS_FAILURE(status))
6164 {
6165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6166 "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]6167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6168 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6169 pAddBAReqParams->status =
6170 CONVERT_WDI2SIR_STATUS(status) ;
6171 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6172 /*Reset the WDA state to READY */
6173 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6174 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6175 vos_mem_free(pWdaParams);
6176 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6177 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6178}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6179/*
6180 * FUNCTION: WDA_DelBANotifyTL
6181 * send DEL BA IND to TL
6182 */
6183void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6184 tDelBAParams *pDelBAReqParams)
6185{
6186 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6187 //tSirMsgQ msg;
6188 vos_msg_t vosMsg;
6189 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6190 if(NULL == pDelBAInd)
6191 {
6192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6193 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6194 VOS_ASSERT(0) ;
6195 return;
6196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6197 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6198 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6199 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6200 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6201
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6202
6203 vosMsg.type = WDA_DELETEBA_IND;
6204 vosMsg.bodyptr = pDelBAInd;
6205 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6206 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6207 {
6208 vosStatus = VOS_STATUS_E_BADMSG;
6209 }
6210}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6211/*
6212 * FUNCTION: WDA_DelBAReqCallback
6213 * send DEL BA RSP back to PE
6214 */
6215void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6216{
6217 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6218 tWDA_CbContext *pWDA;
6219 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6220 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6221 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6222 if(NULL == pWdaParams)
6223 {
6224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6225 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6226 VOS_ASSERT(0) ;
6227 return ;
6228 }
6229 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6230 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6231 /* Notify TL about DEL BA in case of recipinet */
6232 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6233 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6234 {
6235 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6237 /*
6238 * No respone required for WDA_DELBA_IND so just free the request
6239 * param here
6240 */
6241 vos_mem_free(pDelBAReqParams);
6242 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6243 vos_mem_free(pWdaParams);
6244 return ;
6245}
6246
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6247/*
6248 * FUNCTION: WDA_ProcessDelBAReq
6249 * Request to WDI to Update the DELBA REQ params.
6250 */
6251VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6252 tDelBAParams *pDelBAReqParams)
6253{
6254 WDI_Status status = WDI_STATUS_SUCCESS ;
6255 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6256 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6257 sizeof(WDI_DelBAReqParamsType)) ;
6258 tWDA_ReqParams *pWdaParams ;
6259 tANI_U16 staIdx = 0;
6260 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6262 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6263 if(NULL == wdiDelBAReqParam)
6264 {
6265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6266 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6267 VOS_ASSERT(0);
6268 return VOS_STATUS_E_NOMEM;
6269 }
6270 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6271 if(NULL == pWdaParams)
6272 {
6273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6274 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6275 VOS_ASSERT(0);
6276 vos_mem_free(wdiDelBAReqParam);
6277 return VOS_STATUS_E_NOMEM;
6278 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6279 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6280 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6281 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6282 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6283 pWdaParams->pWdaContext = pWDA;
6284 /* Store DEL BA pointer, as this will be used for response */
6285 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6286 /* store Params pass it to WDI */
6287 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6288 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6289 * maintained in WDA, so that WDA can retry for another BA session
6290 */
6291 staIdx = pDelBAReqParams->staIdx;
6292 tid = pDelBAReqParams->baTID;
6293 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6294 status = WDI_DelBAReq(wdiDelBAReqParam,
6295 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6296 if(IS_WDI_STATUS_FAILURE(status))
6297 {
6298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6299 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6300 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6301 vos_mem_free(pWdaParams->wdaMsgParam);
6302 vos_mem_free(pWdaParams);
6303 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6304 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6305}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6306
6307/*
6308 * FUNCTION: WDA_UpdateChReqCallback
6309 *
6310 */
6311void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6312{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6313 tWDA_ReqParams *pWdaParams;
6314 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6315 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6316 WDI_UpdateChannelReqinfoType *pChanInfoType;
6317 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6318
6319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6320 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6321 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6322 {
6323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6324 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6325 VOS_ASSERT(0);
6326 return;
6327 }
6328
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6329 pWdaParams = (tWDA_ReqParams *)pUserData;
6330 pwdiUpdateChReqParam =
6331 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6332 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6333 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6334 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6335 /*
6336 * currently there is no response message is expected between PE and
6337 * WDA, Failure return from WDI is a ASSERT condition
6338 */
6339 vos_mem_free(pChanInfoType);
6340 vos_mem_free(pChanList);
6341 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6342 vos_mem_free(pWdaParams);
6343
6344 return;
6345}
6346
6347/*
6348 * FUNCTION: WDA_ProcessUpdateChannelList
6349 * Request to WDI to Update the ChannelList params.
6350 */
6351VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6352 tSirUpdateChanList *pChanList)
6353{
6354 WDI_Status status = WDI_STATUS_SUCCESS;
6355 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6356 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6357 WDI_UpdateChannelReqinfoType *pChanInfoType;
6358 tWDA_ReqParams *pWdaParams;
6359 wpt_uint8 i;
6360
6361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6362 "------> %s " ,__func__);
6363 if(NULL == pChanList)
6364 {
6365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6366 "%s: NULL pChanList", __func__);
6367 VOS_ASSERT(0);
6368 return VOS_STATUS_E_INVAL;
6369 }
6370
6371 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6372 {
6373 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6374 "Update channel list capability Not Supported");
6375 vos_mem_free(pChanList);
6376 return VOS_STATUS_E_INVAL;
6377 }
6378
6379 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6380 sizeof(WDI_UpdateChReqParamsType));
6381 if(NULL == pwdiUpdateChReqParam)
6382 {
6383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6384 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6385 __func__);
6386 VOS_ASSERT(0);
6387 vos_mem_free(pChanList);
6388 return VOS_STATUS_E_NOMEM;
6389 }
6390 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6391 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6392 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6393 pChanList->numChan);
6394 if(NULL == pChanInfoType)
6395 {
6396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6397 "%s: VOS MEM Alloc Failure", __func__);
6398 VOS_ASSERT(0);
6399 vos_mem_free(pChanList);
6400 vos_mem_free(pwdiUpdateChReqParam);
6401 return VOS_STATUS_E_NOMEM;
6402 }
6403 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6404 * pChanList->numChan);
6405 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6406
6407 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6408 if(NULL == pWdaParams)
6409 {
6410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6411 "%s: VOS MEM Alloc Failure", __func__);
6412 VOS_ASSERT(0);
6413 vos_mem_free(pChanList);
6414 vos_mem_free(pChanInfoType);
6415 vos_mem_free(pwdiUpdateChReqParam);
6416 return VOS_STATUS_E_NOMEM;
6417 }
6418 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6419
6420 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6421 {
6422 pChanInfoType->mhz =
6423 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6424
6425 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6426 pChanInfoType->band_center_freq2 = 0;
6427
6428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6429 "chan[%d] = %u", i, pChanInfoType->mhz);
6430 if (pChanList->chanParam[i].dfsSet)
6431 {
6432 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6434 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6435 pChanList->chanParam[i].dfsSet);
6436 }
6437
6438 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6439 {
6440 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6441 }
6442 else
6443 {
6444 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6445 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6446 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6447 }
6448
6449 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6450 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6451
6452 pChanInfoType++;
6453 }
6454
6455 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6456 pWdaParams->pWdaContext = pWDA;
6457 pWdaParams->wdaMsgParam = (void *)pChanList;
6458 /* store Params pass it to WDI */
6459 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6460 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6461 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6462 if(IS_WDI_STATUS_FAILURE(status))
6463 {
6464 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6465 "Failure in Update Channel REQ Params WDI API, free all the memory");
6466 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6467 vos_mem_free(pwdiUpdateChReqParam);
6468 vos_mem_free(pWdaParams->wdaMsgParam);
6469 vos_mem_free(pWdaParams);
6470 }
6471 return CONVERT_WDI2VOS_STATUS(status);
6472}
6473
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6474/*
6475 * FUNCTION: WDA_AddTSReqCallback
6476 * send ADD TS RSP back to PE
6477 */
6478void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6479{
6480 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6481 tWDA_CbContext *pWDA;
6482 tAddTsParams *pAddTsReqParams;
6483
6484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6485 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6486 if(NULL == pWdaParams)
6487 {
6488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6489 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6490 VOS_ASSERT(0) ;
6491 return ;
6492 }
6493 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6494 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6495 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6496 vos_mem_free(pWdaParams);
6497
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6498 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6499 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6500 return ;
6501}
6502
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6503/*
6504 * FUNCTION: WDA_ProcessAddTSReq
6505 * Request to WDI to Update the ADD TS REQ params.
6506 */
6507VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6508 tAddTsParams *pAddTsReqParams)
6509{
6510 WDI_Status status = WDI_STATUS_SUCCESS ;
6511 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6512 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6513 sizeof(WDI_AddTSReqParamsType)) ;
6514 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6516 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6517 if(NULL == wdiAddTSReqParam)
6518 {
6519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6520 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6521 VOS_ASSERT(0);
6522 return VOS_STATUS_E_NOMEM;
6523 }
6524 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6525 if(NULL == pWdaParams)
6526 {
6527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6528 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6529 VOS_ASSERT(0);
6530 vos_mem_free(wdiAddTSReqParam);
6531 return VOS_STATUS_E_NOMEM;
6532 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6533 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6534 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6535 //TS IE
6536 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6537 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6538 pAddTsReqParams->tspec.length;
6539
6540 //TS IE : TS INFO : TRAFFIC
6541 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6542 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6543 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6544 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6545 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6546 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6547 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6548 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6549 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6550 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6551 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6552 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6553 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6554 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6555 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6556 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6557
6558 //TS IE : TS INFO : SCHEDULE
6559 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6560 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6561 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6562 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6563 //TS IE
6564 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6565 pAddTsReqParams->tspec.nomMsduSz;
6566 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6567 pAddTsReqParams->tspec.maxMsduSz;
6568 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6569 pAddTsReqParams->tspec.minSvcInterval;
6570 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6571 pAddTsReqParams->tspec.maxSvcInterval;
6572 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6573 pAddTsReqParams->tspec.inactInterval;
6574 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6575 pAddTsReqParams->tspec.suspendInterval;
6576 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6577 pAddTsReqParams->tspec.svcStartTime;
6578 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6579 pAddTsReqParams->tspec.minDataRate;
6580 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6581 pAddTsReqParams->tspec.meanDataRate;
6582 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6583 pAddTsReqParams->tspec.peakDataRate;
6584 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6585 pAddTsReqParams->tspec.maxBurstSz;
6586 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6587 pAddTsReqParams->tspec.delayBound;
6588 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6589 pAddTsReqParams->tspec.minPhyRate;
6590 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6591 pAddTsReqParams->tspec.surplusBw;
6592 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6593 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6594 /* TODO: tAddTsParams doesn't have the following fields */
6595#if 0
6596 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6597 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6598 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6599 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6600#endif
6601 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6602
6603 pWdaParams->pWdaContext = pWDA;
6604 /* Store ADD TS pointer, as this will be used for response */
6605 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6606 /* store Params pass it to WDI */
6607 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6608 status = WDI_AddTSReq(wdiAddTSReqParam,
6609 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6610 if(IS_WDI_STATUS_FAILURE(status))
6611 {
6612 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6613 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6614 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6615 vos_mem_free(pWdaParams);
6616 pAddTsReqParams->status = eSIR_FAILURE ;
6617 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6618 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6619 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6620}
6621
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6622/*
6623 * FUNCTION: WDA_DelTSReqCallback
6624 * send DEL TS RSP back to PE
6625 */
6626void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6627{
6628 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6630 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6631 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6632 vos_mem_free(pWdaParams->wdaMsgParam) ;
6633 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6634 /*
6635 * No respone required for WDA_DEL_TS_REQ so just free the request
6636 * param here
6637 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6638 return ;
6639}
6640
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6641/*
6642 * FUNCTION: WDA_ProcessDelTSReq
6643 * Request to WDI to Update the DELTS REQ params.
6644 */
6645VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6646 tDelTsParams *pDelTSReqParams)
6647{
6648 WDI_Status status = WDI_STATUS_SUCCESS ;
6649 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6650 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6651 sizeof(WDI_DelTSReqParamsType)) ;
6652 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6654 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6655 if(NULL == wdiDelTSReqParam)
6656 {
6657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6658 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6659 VOS_ASSERT(0);
6660 return VOS_STATUS_E_NOMEM;
6661 }
6662 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6663 if(NULL == pWdaParams)
6664 {
6665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6666 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6667 VOS_ASSERT(0);
6668 vos_mem_free(wdiDelTSReqParam);
6669 return VOS_STATUS_E_NOMEM;
6670 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6671 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6672 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6673 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6674 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6675 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6676 pWdaParams->pWdaContext = pWDA;
6677 /* Store DEL TS pointer, as this will be used for response */
6678 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6679 /* store Params pass it to WDI */
6680 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6681 status = WDI_DelTSReq(wdiDelTSReqParam,
6682 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6683 if(IS_WDI_STATUS_FAILURE(status))
6684 {
6685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6686 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6687 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6688 vos_mem_free(pWdaParams->wdaMsgParam);
6689 vos_mem_free(pWdaParams);
6690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6691 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6692}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6693/*
6694 * FUNCTION: WDA_UpdateBeaconParamsCallback
6695 * Free the memory. No need to send any response to PE in this case
6696 */
6697void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6698{
6699 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6701 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6702 if(NULL == pWdaParams)
6703 {
6704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6705 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6706 VOS_ASSERT(0) ;
6707 return ;
6708 }
6709 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6710 vos_mem_free(pWdaParams->wdaMsgParam) ;
6711 vos_mem_free(pWdaParams);
6712 /*
6713 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6714 * param here
6715 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6716 return ;
6717}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6718/*
6719 * FUNCTION: WDA_ProcessUpdateBeaconParams
6720 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6721 */
6722VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6723 tUpdateBeaconParams *pUpdateBeaconParams)
6724{
6725 WDI_Status status = WDI_STATUS_SUCCESS ;
6726 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6727 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6728 sizeof(WDI_UpdateBeaconParamsType)) ;
6729 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6731 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6732 if(NULL == wdiUpdateBeaconParams)
6733 {
6734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6735 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6736 VOS_ASSERT(0);
6737 return VOS_STATUS_E_NOMEM;
6738 }
6739 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6740 if(NULL == pWdaParams)
6741 {
6742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6743 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6744 VOS_ASSERT(0);
6745 vos_mem_free(wdiUpdateBeaconParams);
6746 return VOS_STATUS_E_NOMEM;
6747 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6748 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6749 pUpdateBeaconParams->bssIdx;
6750 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6751 pUpdateBeaconParams->fShortPreamble;
6752 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6753 pUpdateBeaconParams->fShortSlotTime;
6754 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6755 pUpdateBeaconParams->beaconInterval;
6756 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6757 pUpdateBeaconParams->llaCoexist;
6758 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6759 pUpdateBeaconParams->llbCoexist;
6760 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6761 pUpdateBeaconParams->llgCoexist;
6762 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6763 pUpdateBeaconParams->ht20MhzCoexist;
6764 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6765 pUpdateBeaconParams->llnNonGFCoexist;
6766 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6767 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6768 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6769 pUpdateBeaconParams->fRIFSMode;
6770 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6771 pUpdateBeaconParams->paramChangeBitmap;
6772 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6773
6774 pWdaParams->pWdaContext = pWDA;
6775 /* Store UpdateBeacon Req pointer, as this will be used for response */
6776 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6777 /* store Params pass it to WDI */
6778 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6779 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6780 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6781 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6782 if(IS_WDI_STATUS_FAILURE(status))
6783 {
6784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6785 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6786 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6787 vos_mem_free(pWdaParams->wdaMsgParam);
6788 vos_mem_free(pWdaParams);
6789 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6790 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6791}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6792#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6793/*
6794 * FUNCTION: WDA_TSMStatsReqCallback
6795 * send TSM Stats RSP back to PE
6796 */
6797void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6798{
6799 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6800 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6801 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6802 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6803
6804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6805 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6806 if(NULL == pWdaParams)
6807 {
6808 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6809 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6810 VOS_ASSERT(0) ;
6811 return ;
6812 }
6813 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6814 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6815
6816 if(NULL == pGetTsmStatsReqParams)
6817 {
6818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6819 "%s: pGetTsmStatsReqParams received NULL", __func__);
6820 VOS_ASSERT(0);
6821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6822 vos_mem_free(pWdaParams);
6823 return;
6824 }
6825
6826 pTsmRspParams =
6827 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6828 if( NULL == pTsmRspParams )
6829 {
6830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6831 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6832 VOS_ASSERT( 0 );
6833 return ;
6834 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6835 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6836 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6837 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6838
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6839 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6840 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6841 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6842 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6843 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6844 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6845 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6846 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6847 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6848 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6849
6850 /* Assign get tsm stats req req (backup) in to the response */
6851 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6852
6853 /* free WDI command buffer */
6854 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6855 vos_mem_free(pWdaParams);
6856
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6857 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6858 return ;
6859}
6860
6861
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6862/*
6863 * FUNCTION: WDA_ProcessTsmStatsReq
6864 * Request to WDI to get the TSM Stats params.
6865 */
6866VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6867 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6868{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6869 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6870 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6871 tWDA_ReqParams *pWdaParams = NULL;
6872 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6873
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6875 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6876 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6877 sizeof(WDI_TSMStatsReqParamsType));
6878 if(NULL == wdiTSMReqParam)
6879 {
6880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6881 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6882 VOS_ASSERT(0);
6883 return VOS_STATUS_E_NOMEM;
6884 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6885 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6886 if(NULL == pWdaParams)
6887 {
6888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6889 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6890 VOS_ASSERT(0);
6891 vos_mem_free(wdiTSMReqParam);
6892 return VOS_STATUS_E_NOMEM;
6893 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6894 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6895 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6896 pTsmStats->bssId,
6897 sizeof(wpt_macAddr));
6898 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6899
6900 pWdaParams->pWdaContext = pWDA;
6901 /* Store TSM Stats pointer, as this will be used for response */
6902 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6903 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6904 status = WDI_TSMStatsReq(wdiTSMReqParam,
6905 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6906 if(IS_WDI_STATUS_FAILURE(status))
6907 {
6908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6909 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6910 vos_mem_free(pWdaParams);
6911
6912 pGetTsmStatsRspParams =
6913 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6914 if(NULL == pGetTsmStatsRspParams)
6915 {
6916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6917 "%s: VOS MEM Alloc Failure", __func__);
6918 VOS_ASSERT(0);
6919 vos_mem_free(pTsmStats);
6920 return VOS_STATUS_E_NOMEM;
6921 }
6922 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6923 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6924 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6925
6926 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6928 return CONVERT_WDI2VOS_STATUS(status) ;
6929}
6930#endif
6931/*
6932 * FUNCTION: WDA_SendBeaconParamsCallback
6933 * No need to send any response to PE in this case
6934 */
6935void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6936{
6937
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6939 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6940 return ;
6941}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6942/*
6943 * FUNCTION: WDA_ProcessSendBeacon
6944 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6945 * start beacon trasmission
6946 */
6947VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6948 tSendbeaconParams *pSendbeaconParams)
6949{
6950 WDI_Status status = WDI_STATUS_SUCCESS ;
6951 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6953 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6954 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6955 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6956 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6957 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6958 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6959 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6960 /* p2pIeOffset should be atleast greater than timIeOffset */
6961 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6962 (pSendbeaconParams->p2pIeOffset <
6963 pSendbeaconParams->timIeOffset))
6964 {
6965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6966 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6967 VOS_ASSERT( 0 );
6968 return WDI_STATUS_E_FAILURE;
6969 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6970 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6971 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6972 /* Copy the beacon template to local buffer */
6973 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6974 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6975 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6976
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6977 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6978 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6979 if(IS_WDI_STATUS_FAILURE(status))
6980 {
6981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6982 "Failure in SEND BEACON REQ Params WDI API" );
6983 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6984 vos_mem_free(pSendbeaconParams);
6985 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6986}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6987/*
6988 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6989 * No need to send any response to PE in this case
6990 */
6991void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6992{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6994 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6995 return ;
6996}
6997
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6998/*
6999 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
7000 * Request to WDI to send the probe response template to HAL to update the TPE memory and
7001 * send probe response
7002 */
7003VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
7004 tSendProbeRespParams *pSendProbeRspParams)
7005{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7006 WDI_Status status = WDI_STATUS_SUCCESS;
7007 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
7008 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7010 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7011
7012 if (!wdiSendProbeRspParam)
7013 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
7014
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7015 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7016 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7017 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7018 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7019 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7020 /* Copy the Probe Response template to local buffer */
7021 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7022 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7023 pSendProbeRspParams->pProbeRespTemplate,
7024 pSendProbeRspParams->probeRespTemplateLen);
7025 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7026 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7027 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
7028 WDI_PROBE_REQ_BITMAP_IE_LEN);
7029
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7030 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7031
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7032 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7033 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7034 if(IS_WDI_STATUS_FAILURE(status))
7035 {
7036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7037 "Failure in SEND Probe RSP Params WDI API" );
7038 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7039 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7040 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7041 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7042}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7043#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7044/*
7045 * FUNCTION: WDA_SetMaxTxPowerCallBack
7046 * send the response to PE with power value received from WDI
7047 */
7048void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7049 void* pUserData)
7050{
7051 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7052 tWDA_CbContext *pWDA = NULL;
7053 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
7054
7055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7056 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7057 if(NULL == pWdaParams)
7058 {
7059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7060 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7061 VOS_ASSERT(0) ;
7062 return ;
7063 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7064 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7065 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7066 if( NULL == pMaxTxPowerParams )
7067 {
7068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7069 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7070 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7071 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7072 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7073 return ;
7074 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7075
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7076
7077 /*need to free memory for the pointers used in the
7078 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7079 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7080 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7081 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7082
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7083
7084 /* send response to UMAC*/
7085 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7086
7087 return;
7088}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7089/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7090 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7091 * Request to WDI to send set Max Tx Power Request
7092 */
7093 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7094 tMaxTxPowerParams *MaxTxPowerParams)
7095{
7096 WDI_Status status = WDI_STATUS_SUCCESS;
7097 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7098 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7099
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7101 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7102
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7103 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7104 sizeof(WDI_SetMaxTxPowerParamsType));
7105 if(NULL == wdiSetMaxTxPowerParams)
7106 {
7107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7108 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7109 VOS_ASSERT(0);
7110 return VOS_STATUS_E_NOMEM;
7111 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7112 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7113 if(NULL == pWdaParams)
7114 {
7115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7116 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7117 vos_mem_free(wdiSetMaxTxPowerParams);
7118 VOS_ASSERT(0);
7119 return VOS_STATUS_E_NOMEM;
7120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7121 /* Copy.Max.Tx.Power Params to WDI structure */
7122 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7123 MaxTxPowerParams->bssId,
7124 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7125 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7126 MaxTxPowerParams->selfStaMacAddr,
7127 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7128 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7129 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7130 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7131 pWdaParams->pWdaContext = pWDA;
7132 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7133 /* store Params pass it to WDI */
7134 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7135 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7136 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7137 if(IS_WDI_STATUS_FAILURE(status))
7138 {
7139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7140 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7141 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7142 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7143 /* send response to UMAC*/
7144 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7145 }
7146 return CONVERT_WDI2VOS_STATUS(status);
7147
7148}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7149#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7150
7151/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7152 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7153 * send the response to PE with power value received from WDI
7154 */
7155void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7156 *pwdiSetMaxTxPowerPerBandRsp,
7157 void* pUserData)
7158{
7159 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7160 tWDA_CbContext *pWDA = NULL;
7161 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7162
7163 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7164 "<------ %s ", __func__);
7165 if (NULL == pWdaParams)
7166 {
7167 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7168 "%s: pWdaParams received NULL", __func__);
7169 VOS_ASSERT(0);
7170 return ;
7171 }
7172 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7173 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7174 if ( NULL == pMxTxPwrPerBandParams )
7175 {
7176 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7177 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7178 VOS_ASSERT(0);
7179 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7180 vos_mem_free(pWdaParams);
7181 return;
7182 }
7183
7184 /*need to free memory for the pointers used in the
7185 WDA Process.Set Max Tx Power Req function*/
7186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7187 vos_mem_free(pWdaParams);
7188 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7189
7190 /* send response to UMAC*/
7191 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7192 pMxTxPwrPerBandParams, 0);
7193
7194 return;
7195}
7196
7197/*
7198 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7199 * Request to WDI to send set Max Tx Power Per band Request
7200 */
7201 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7202 tMaxTxPowerPerBandParams
7203 *MaxTxPowerPerBandParams)
7204{
7205 WDI_Status status = WDI_STATUS_SUCCESS;
7206 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7207 tWDA_ReqParams *pWdaParams = NULL;
7208
7209 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7210 "------> %s ", __func__);
7211
7212 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7213 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7214
7215 if (NULL == wdiSetMxTxPwrPerBandParams)
7216 {
7217 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7218 "%s: VOS MEM Alloc Failure", __func__);
7219 VOS_ASSERT(0);
7220 return VOS_STATUS_E_NOMEM;
7221 }
7222 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7223 if (NULL == pWdaParams)
7224 {
7225 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7226 "%s: VOS MEM Alloc Failure", __func__);
7227 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7228 VOS_ASSERT(0);
7229 return VOS_STATUS_E_NOMEM;
7230 }
7231 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7232 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7233 MaxTxPowerPerBandParams->bandInfo;
7234 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7235 MaxTxPowerPerBandParams->power;
7236 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7237 pWdaParams->pWdaContext = pWDA;
7238 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7239 /* store Params pass it to WDI */
7240 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7241 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7242 WDA_SetMaxTxPowerPerBandCallBack,
7243 pWdaParams);
7244 if (IS_WDI_STATUS_FAILURE(status))
7245 {
7246 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7247 "Failure in SET MAX TX Power REQ Params WDI API,"
7248 " free all the memory");
7249 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7250 vos_mem_free(pWdaParams);
7251 /* send response to UMAC*/
7252 WDA_SendMsg(pWDA,
7253 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7254 MaxTxPowerPerBandParams, 0);
7255 }
7256 return CONVERT_WDI2VOS_STATUS(status);
7257}
7258
7259/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7260 * FUNCTION: WDA_SetTxPowerCallBack
7261 * send the response to PE with power value received from WDI
7262 */
7263void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7264 void* pUserData)
7265{
7266 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7267 tWDA_CbContext *pWDA = NULL;
7268 tSirSetTxPowerReq *pTxPowerParams = NULL;
7269
7270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7271 "<------ %s ", __func__);
7272 if(NULL == pWdaParams)
7273 {
7274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7275 "%s: pWdaParams received NULL", __func__);
7276 VOS_ASSERT(0) ;
7277 return ;
7278 }
7279 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7280 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7281 if(NULL == pTxPowerParams)
7282 {
7283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7284 "%s: pTxPowerParams received NULL " ,__func__);
7285 VOS_ASSERT(0);
7286 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7287 vos_mem_free(pWdaParams);
7288 return ;
7289 }
7290
7291 /*need to free memory for the pointers used in the
7292 WDA Process.Set Max Tx Power Req function*/
7293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7294 vos_mem_free(pWdaParams);
7295
7296 /* send response to UMAC*/
7297 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7298 return;
7299}
7300
7301/*
7302 * FUNCTION: WDA_ProcessSetTxPowerReq
7303 * Request to WDI to send set Tx Power Request
7304 */
7305 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7306 tSirSetTxPowerReq *txPowerParams)
7307{
7308 WDI_Status status = WDI_STATUS_SUCCESS;
7309 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7310 tWDA_ReqParams *pWdaParams = NULL;
7311
7312 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7313 "------> %s ", __func__);
7314
7315 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7316 sizeof(WDI_SetTxPowerParamsType));
7317 if(NULL == wdiSetTxPowerParams)
7318 {
7319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7320 "%s: VOS MEM Alloc Failure", __func__);
7321 VOS_ASSERT(0);
7322 return VOS_STATUS_E_NOMEM;
7323 }
7324 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7325 if(NULL == pWdaParams)
7326 {
7327 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7328 "%s: VOS MEM Alloc Failure", __func__);
7329 vos_mem_free(wdiSetTxPowerParams);
7330 VOS_ASSERT(0);
7331 return VOS_STATUS_E_NOMEM;
7332 }
7333 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7334 txPowerParams->bssIdx;
7335 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7336 txPowerParams->mwPower;
7337 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7338 pWdaParams->pWdaContext = pWDA;
7339 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7340 /* store Params pass it to WDI */
7341 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7342 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7343 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7344 if(IS_WDI_STATUS_FAILURE(status))
7345 {
7346 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7347 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7348 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7349 vos_mem_free(pWdaParams);
7350 /* send response to UMAC*/
7351 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7352 }
7353 return CONVERT_WDI2VOS_STATUS(status);
7354}
7355
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7356/*
7357 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7358 * Free the memory. No need to send any response to PE in this case
7359 */
7360void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7361{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7362 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7363
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7365 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7366
7367 if(NULL == pWdaParams)
7368 {
7369 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7370 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7371 VOS_ASSERT(0) ;
7372 return ;
7373 }
7374
7375 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7376 vos_mem_free(pWdaParams->wdaMsgParam) ;
7377 vos_mem_free(pWdaParams);
7378
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7379 /*
7380 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7381 * so just free the request param here
7382 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7383 return ;
7384}
7385
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7386/*
7387 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7388 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7389 */
7390VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7391 tP2pPsParams *pP2pPsConfigParams)
7392{
7393 WDI_Status status = WDI_STATUS_SUCCESS ;
7394 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7395 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7396 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7397 tWDA_ReqParams *pWdaParams = NULL;
7398
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7400 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7401 if(NULL == wdiSetP2PGONOAReqParam)
7402 {
7403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7404 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7405 VOS_ASSERT(0);
7406 return VOS_STATUS_E_NOMEM;
7407 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7408
7409 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7410 if(NULL == pWdaParams)
7411 {
7412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7413 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7414 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7415 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7416 VOS_ASSERT(0);
7417 return VOS_STATUS_E_NOMEM;
7418 }
7419
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7420 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7421 pP2pPsConfigParams->opp_ps;
7422 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7423 pP2pPsConfigParams->ctWindow;
7424 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7425 pP2pPsConfigParams->count;
7426 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7427 pP2pPsConfigParams->duration;
7428 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7429 pP2pPsConfigParams->interval;
7430 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7431 pP2pPsConfigParams->single_noa_duration;
7432 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7433 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7434
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7435 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7436 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7437 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7438
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7439 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7440 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7441 pWdaParams->pWdaContext = pWDA;
7442
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7443 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7444 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7445
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7446 if(IS_WDI_STATUS_FAILURE(status))
7447 {
7448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7449 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7450 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7451 vos_mem_free(pWdaParams->wdaMsgParam);
7452 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7453 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7454 return CONVERT_WDI2VOS_STATUS(status);
7455
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7456}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7457
7458#ifdef FEATURE_WLAN_TDLS
7459/*
7460 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7461 * Free the memory. No need to send any response to PE in this case
7462 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7463void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7464 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7465{
7466 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7467 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7468 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7469
7470
7471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7472 "<------ %s " ,__func__);
7473 if(NULL == pWdaParams)
7474 {
7475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7476 "%s: pWdaParams received NULL", __func__);
7477 VOS_ASSERT(0) ;
7478 return ;
7479 }
7480 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7481
7482 if(NULL == pWdaParams)
7483 {
7484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7485 "%s: pWdaParams received NULL", __func__);
7486 VOS_ASSERT(0) ;
7487 return ;
7488 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7489 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7490 if( NULL == pTdlsLinkEstablishParams )
7491 {
7492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7493 "%s: pTdlsLinkEstablishParams "
7494 "received NULL " ,__func__);
7495 VOS_ASSERT(0);
7496 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7497 vos_mem_free(pWdaParams);
7498 return ;
7499 }
7500 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7501 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7502 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7503 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7504 /* send response to UMAC*/
7505 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7506
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7507 return ;
7508}
7509
7510VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7511 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7512{
7513 WDI_Status status = WDI_STATUS_SUCCESS ;
7514 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7515 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7516 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7517 tWDA_ReqParams *pWdaParams = NULL;
7518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7519 "------> %s " ,__func__);
7520 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7521 {
7522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7523 "%s: VOS MEM Alloc Failure", __func__);
7524 VOS_ASSERT(0);
7525 return VOS_STATUS_E_NOMEM;
7526 }
7527 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7528 if(NULL == pWdaParams)
7529 {
7530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7531 "%s: VOS MEM Alloc Failure", __func__);
7532 vos_mem_free(pTdlsLinkEstablishParams);
7533 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7534 VOS_ASSERT(0);
7535 return VOS_STATUS_E_NOMEM;
7536 }
7537 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7538 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7539 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7540 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7541 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7542 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7543 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7544 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7545 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7546 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7547 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7548 pTdlsLinkEstablishParams->isOffChannelSupported;
7549
7550 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7551 pTdlsLinkEstablishParams->validChannels,
7552 pTdlsLinkEstablishParams->validChannelsLen);
7553
7554 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7555 pTdlsLinkEstablishParams->validChannelsLen;
7556
7557 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7558 pTdlsLinkEstablishParams->validOperClasses,
7559 pTdlsLinkEstablishParams->validOperClassesLen);
7560 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7561 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7562
7563 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7564 /* Store msg pointer from PE, as this will be used for response */
7565 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7566 /* store Params pass it to WDI */
7567 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7568 pWdaParams->pWdaContext = pWDA;
7569
7570 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7571 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7572 WDA_SetTDLSLinkEstablishReqParamsCallback,
7573 pWdaParams);
7574 if(IS_WDI_STATUS_FAILURE(status))
7575 {
7576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7577 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7578 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7579 vos_mem_free(pWdaParams->wdaMsgParam);
7580 vos_mem_free(pWdaParams);
7581 }
7582 return CONVERT_WDI2VOS_STATUS(status);
7583}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7584
7585// tdlsoffchan
7586void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
7587 void* pUserData)
7588{
7589 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7590 tWDA_CbContext *pWDA = NULL;
7591 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
7592
7593
7594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7595 "<------ %s " ,__func__);
7596 if(NULL == pWdaParams)
7597 {
7598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7599 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7600 VOS_ASSERT(0) ;
7601 return ;
7602 }
7603 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7604
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7605 if(NULL == pWdaParams)
7606 {
7607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7608 "%s: pWdaParams received NULL", __func__);
7609 VOS_ASSERT(0) ;
7610 return ;
7611 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7612 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7613 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7614 {
7615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7616 "%s: pTdlsChanSwitchParams "
7617 "received NULL " ,__func__);
7618 VOS_ASSERT(0);
7619 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7620 vos_mem_free(pWdaParams);
7621 return ;
7622 }
7623 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
7624 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7625 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7626 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7627 /* send response to UMAC*/
7628 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7629
7630 return ;
7631}
7632VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
7633 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
7634{
7635 WDI_Status status = WDI_STATUS_SUCCESS ;
7636 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
7637 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
7638 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
7639 tWDA_ReqParams *pWdaParams = NULL;
7640
7641 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7642 "Enter: %s ",__func__);
7643 if(NULL == wdiSetTDLSChanSwitchReqParam)
7644 {
7645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7646 "%s: VOS MEM Alloc Failure", __func__);
7647 VOS_ASSERT(0);
7648 return VOS_STATUS_E_NOMEM;
7649 }
7650
7651 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7652 if(NULL == pWdaParams)
7653 {
7654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7655 "%s: VOS MEM Alloc Failure", __func__);
7656 vos_mem_free(pTdlsChanSwitchParams);
7657 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
7658 VOS_ASSERT(0);
7659 return VOS_STATUS_E_NOMEM;
7660 }
7661 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
7662 pTdlsChanSwitchParams->staIdx;
7663 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
7664 pTdlsChanSwitchParams->tdlsSwMode;
7665 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
7666 pTdlsChanSwitchParams->operClass;
7667 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
7668 pTdlsChanSwitchParams->tdlsOffCh;
7669 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
7670 pTdlsChanSwitchParams->tdlsOffChBwOffset;
7671
7672
7673 /* Store msg pointer from PE, as this will be used for response */
7674 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
7675 /* store Params pass it to WDI */
7676 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
7677 pWdaParams->pWdaContext = pWDA;
7678 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
7679 (WDI_SetTDLSChanSwitchReqParamsRspCb)
7680 WDA_SetTDLSChanSwitchReqParamsCallback,
7681 pWdaParams);
7682 if(IS_WDI_STATUS_FAILURE(status))
7683 {
7684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7685 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
7686 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7687 vos_mem_free(pWdaParams->wdaMsgParam);
7688 vos_mem_free(pWdaParams);
7689 }
7690 return CONVERT_WDI2VOS_STATUS(status);
7691}
7692#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7693
7694
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7695#ifdef WLAN_FEATURE_VOWIFI_11R
7696/*
7697 * FUNCTION: WDA_AggrAddTSReqCallback
7698 * send ADD AGGREGATED TS RSP back to PE
7699 */
7700void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7701{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7702 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7703 tWDA_CbContext *pWDA;
7704 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7705 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7707 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7708 if(NULL == pWdaParams)
7709 {
7710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7711 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7712 VOS_ASSERT(0) ;
7713 return ;
7714 }
7715
7716 pWDA = pWdaParams->pWdaContext;
7717 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7718
7719 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7720 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7721 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7722 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7723 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7724
7725 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7726 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7727 return ;
7728}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7729/*
7730 * FUNCTION: WDA_ProcessAddTSReq
7731 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7732 */
7733VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7734 tAggrAddTsParams *pAggrAddTsReqParams)
7735{
7736 WDI_Status status = WDI_STATUS_SUCCESS ;
7737 int i;
7738 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7739 tWDA_ReqParams *pWdaParams = NULL;
7740
7741
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7743 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7744 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7745 sizeof(WDI_AggrAddTSReqParamsType)) ;
7746 if(NULL == wdiAggrAddTSReqParam)
7747 {
7748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7749 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7750 VOS_ASSERT(0);
7751 return VOS_STATUS_E_NOMEM;
7752 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7753
7754
7755 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7756 if(NULL == pWdaParams)
7757 {
7758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7759 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7760 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7761 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7762 VOS_ASSERT(0);
7763 return VOS_STATUS_E_NOMEM;
7764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7765 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7766 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7767 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7768 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7769 {
7770 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7771 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7772 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7773 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7774 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7775 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7776 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7777 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7778 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7779 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7780 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7781 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7782 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7783 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7784 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7785 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7786 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7787 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7788 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7789 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7790 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7791 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7792 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7793 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7794 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7795 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7796 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7797 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7798 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7799 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7800 pAggrAddTsReqParams->tspec[i].inactInterval;
7801 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7802 pAggrAddTsReqParams->tspec[i].suspendInterval;
7803 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7804 pAggrAddTsReqParams->tspec[i].svcStartTime;
7805 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7806 pAggrAddTsReqParams->tspec[i].minDataRate;
7807 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7808 pAggrAddTsReqParams->tspec[i].meanDataRate;
7809 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7810 pAggrAddTsReqParams->tspec[i].peakDataRate;
7811 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7812 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7813 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7814 pAggrAddTsReqParams->tspec[i].delayBound;
7815 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7816 pAggrAddTsReqParams->tspec[i].minPhyRate;
7817 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7818 pAggrAddTsReqParams->tspec[i].surplusBw;
7819 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7820 pAggrAddTsReqParams->tspec[i].mediumTime;
7821 }
7822
7823 /* TODO: tAggrAddTsParams doesn't have the following fields */
7824#if 0
7825 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7826 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7827 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7828 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7829#endif
7830 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7831
7832 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7833 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7834 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7835 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7836
7837 pWdaParams->pWdaContext = pWDA;
7838
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7839 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7840 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7841
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7842 if(IS_WDI_STATUS_FAILURE(status))
7843 {
7844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7845 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7846 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7847 vos_mem_free(pWdaParams);
7848
7849 /* send the failure response back to PE*/
7850 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7851 {
7852 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7853 }
7854
7855 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7856 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7857 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7858 return CONVERT_WDI2VOS_STATUS(status) ;
7859}
7860#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7861/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7862 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7863 * send Enter IMPS RSP back to PE
7864 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7865void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7866{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7867 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7868 tWDA_CbContext *pWDA;
7869
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7871 "<------ %s status=%d" ,__func__,status);
7872 if(NULL == pWdaParams)
7873 {
7874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7875 "%s: pWdaParams received NULL", __func__);
7876 VOS_ASSERT(0);
7877 return;
7878 }
7879
7880 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7881
7882 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7883 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7884 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7885 return ;
7886}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7887
7888
7889/*
7890 * FUNCTION: WDA_EnterImpsReqCallback
7891 * Free memory and send Enter IMPS RSP back to PE.
7892 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7893 */
7894void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7895{
7896 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7897 tWDA_CbContext *pWDA;
7898
7899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7900 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7901
7902 if(NULL == pWdaParams)
7903 {
7904 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7905 "%s: pWdaParams received NULL", __func__);
7906 VOS_ASSERT(0);
7907 return;
7908 }
7909
7910 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7911
7912 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7913 {
7914 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7915 vos_mem_free(pWdaParams);
7916 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7917 CONVERT_WDI2SIR_STATUS(wdiStatus));
7918 }
7919
7920 return;
7921}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7922/*
7923 * FUNCTION: WDA_ProcessEnterImpsReq
7924 * Request to WDI to Enter IMPS power state.
7925 */
7926VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7927{
7928 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7929 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7930 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7932 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7933
7934
7935 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7936 if (NULL == wdiEnterImpsReqParams)
7937 {
7938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7939 "%s: VOS MEM Alloc Failure", __func__);
7940 VOS_ASSERT(0);
7941 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7942 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7943 return VOS_STATUS_E_NOMEM;
7944 }
7945
7946 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7947 if (NULL == pWdaParams)
7948 {
7949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7950 "%s: VOS MEM Alloc Failure", __func__);
7951 VOS_ASSERT(0);
7952 vos_mem_free(wdiEnterImpsReqParams);
7953 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7954 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7955 return VOS_STATUS_E_NOMEM;
7956 }
7957
7958 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7959 wdiEnterImpsReqParams->pUserData = pWdaParams;
7960
7961 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7962 pWdaParams->wdaMsgParam = NULL;
7963 pWdaParams->pWdaContext = pWDA;
7964
7965 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7966 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7967 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7968 if(IS_WDI_STATUS_FAILURE(status))
7969 {
7970 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7971 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7972 vos_mem_free(wdiEnterImpsReqParams);
7973 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7974 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7976 return CONVERT_WDI2VOS_STATUS(status) ;
7977}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7978/*
7979 * FUNCTION: WDA_ExitImpsReqCallback
7980 * send Exit IMPS RSP back to PE
7981 */
7982void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7983{
7984 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7986 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7987 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7988 return ;
7989}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7990/*
7991 * FUNCTION: WDA_ProcessExitImpsReq
7992 * Request to WDI to Exit IMPS power state.
7993 */
7994VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7995{
7996 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7998 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7999 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8000 if(IS_WDI_STATUS_FAILURE(status))
8001 {
8002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8003 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8004 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8006 return CONVERT_WDI2VOS_STATUS(status) ;
8007}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8008/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8009 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8010 * send Enter BMPS RSP back to PE
8011 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8012void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8013{
8014 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8015 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8016 tEnterBmpsParams *pEnterBmpsRspParams;
8017
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8019 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8020 if(NULL == pWdaParams)
8021 {
8022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8023 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8024 VOS_ASSERT(0) ;
8025 return ;
8026 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8027
8028 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8029 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8030
8031 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8032 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8033
8034 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8035 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8036 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
8037
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8038 return ;
8039}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8040/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8041 * FUNCTION: WDA_EnterBmpsReqCallback
8042 * Free memory and send Enter BMPS RSP back to PE.
8043 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
8044 */
8045void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8046{
8047 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8048 tWDA_CbContext *pWDA;
8049 tEnterBmpsParams *pEnterBmpsRspParams;
8050
8051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8052 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8053
8054 if(NULL == pWdaParams)
8055 {
8056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8057 "%s: pWdaParams received NULL", __func__);
8058 VOS_ASSERT(0);
8059 return;
8060 }
8061
8062 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8063 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8064 pEnterBmpsRspParams->status = wdiStatus;
8065
8066 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8067 {
8068 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8069 vos_mem_free(pWdaParams);
8070 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
8071 }
8072
8073 return;
8074}
8075/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8076 * FUNCTION: WDA_ProcessEnterBmpsReq
8077 * Request to WDI to Enter BMPS power state.
8078 */
8079VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
8080 tEnterBmpsParams *pEnterBmpsReqParams)
8081{
8082 WDI_Status status = WDI_STATUS_SUCCESS;
8083 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
8084 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8086 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8087 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
8088 {
8089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8090 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8091 VOS_ASSERT(0);
8092 return VOS_STATUS_E_FAILURE;
8093 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8094 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
8095 if (NULL == wdiEnterBmpsReqParams)
8096 {
8097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8098 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8099 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8100 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8101 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8102 return VOS_STATUS_E_NOMEM;
8103 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8104 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8105 if (NULL == pWdaParams)
8106 {
8107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8108 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8109 VOS_ASSERT(0);
8110 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8111 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8112 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8113 return VOS_STATUS_E_NOMEM;
8114 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8115 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
8116 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
8117 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
8118 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]8119 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8120 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
8121 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
8122 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8123 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
8124 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8125
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8126 /* Store param pointer as passed in by caller */
8127 /* store Params pass it to WDI */
8128 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8129 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8130 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8131 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8132 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8133 if (IS_WDI_STATUS_FAILURE(status))
8134 {
8135 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8136 "Failure in Enter BMPS REQ WDI API, free all the memory" );
8137 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8138 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8139 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8140 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8142 return CONVERT_WDI2VOS_STATUS(status);
8143}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8144
8145
8146static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
8147 WDI_Status wdiStatus,
8148 tExitBmpsParams *pExitBmpsReqParams)
8149{
8150 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
8151
8152 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
8153}
8154
8155
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8156/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8157 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8158 * send Exit BMPS RSP back to PE
8159 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8160void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8161{
8162 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8163 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8164 tExitBmpsParams *pExitBmpsRspParams;
8165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8167 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8168 if(NULL == pWdaParams)
8169 {
8170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8171 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8172 VOS_ASSERT(0) ;
8173 return ;
8174 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8175
8176 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8177 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8178
8179 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8180 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8181
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8182 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8183 vos_mem_free(pWdaParams) ;
8184
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8185 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8186 return ;
8187}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8188/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8189 * FUNCTION: WDA_ExitBmpsReqCallback
8190 * Free memory and send Exit BMPS RSP back to PE.
8191 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
8192 */
8193void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8194{
8195 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8196 tWDA_CbContext *pWDA;
8197 tExitBmpsParams *pExitBmpsRspParams;
8198
8199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8200 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8201
8202 if(NULL == pWdaParams)
8203 {
8204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8205 "%s: pWdaParams received NULL", __func__);
8206 VOS_ASSERT(0);
8207 return;
8208 }
8209
8210 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8211 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8212 pExitBmpsRspParams->status = wdiStatus;
8213
8214 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8215 {
8216 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8217 vos_mem_free(pWdaParams);
8218 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
8219 }
8220
8221 return;
8222}
8223/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8224 * FUNCTION: WDA_ProcessExitBmpsReq
8225 * Request to WDI to Exit BMPS power state.
8226 */
8227VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
8228 tExitBmpsParams *pExitBmpsReqParams)
8229{
8230 WDI_Status status = WDI_STATUS_SUCCESS ;
8231 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
8232 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
8233 sizeof(WDI_ExitBmpsReqParamsType)) ;
8234 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8236 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8237 if(NULL == wdiExitBmpsReqParams)
8238 {
8239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8240 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8241 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8242 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8243 return VOS_STATUS_E_NOMEM;
8244 }
8245 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8246 if(NULL == pWdaParams)
8247 {
8248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8249 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8250 VOS_ASSERT(0);
8251 vos_mem_free(wdiExitBmpsReqParams);
8252 return VOS_STATUS_E_NOMEM;
8253 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8254 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8255
8256 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
8257
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8258 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
8259 wdiExitBmpsReqParams->pUserData = pWdaParams;
8260
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8261 /* Store param pointer as passed in by caller */
8262 /* store Params pass it to WDI */
8263 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
8264 pWdaParams->pWdaContext = pWDA;
8265 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8266 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8267 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8268 if(IS_WDI_STATUS_FAILURE(status))
8269 {
8270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8271 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8272 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8273 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8274 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8275 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8276 return CONVERT_WDI2VOS_STATUS(status) ;
8277}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8278/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8279 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8280 * send Enter UAPSD RSP back to PE
8281 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8282void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8283{
8284 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8285 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8286 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8288 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8289 if(NULL == pWdaParams)
8290 {
8291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8292 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8293 VOS_ASSERT(0) ;
8294 return ;
8295 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8296
8297 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8298 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8299
8300 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8301 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8302
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8303 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8304 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8305 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8306 return ;
8307}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8308/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8309 * FUNCTION: WDA_EnterUapsdReqCallback
8310 * Free memory and send Enter UAPSD RSP back to PE.
8311 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8312 */
8313void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8314{
8315 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8316 tWDA_CbContext *pWDA;
8317 tUapsdParams *pEnterUapsdRsqParams;
8318
8319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8320 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8321
8322 if(NULL == pWdaParams)
8323 {
8324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8325 "%s: pWdaParams received NULL", __func__);
8326 VOS_ASSERT(0);
8327 return;
8328 }
8329
8330 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8331 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8332 pEnterUapsdRsqParams->status = wdiStatus;
8333
8334 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8335 {
8336 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8337 vos_mem_free(pWdaParams);
8338 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8339 }
8340
8341 return;
8342}
8343/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8344 * FUNCTION: WDA_ProcessEnterUapsdReq
8345 * Request to WDI to Enter UAPSD power state.
8346 */
8347VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8348 tUapsdParams *pEnterUapsdReqParams)
8349{
8350 WDI_Status status = WDI_STATUS_SUCCESS ;
8351 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8352 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8353 sizeof(WDI_EnterUapsdReqParamsType)) ;
8354 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8356 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8357 if(NULL == wdiEnterUapsdReqParams)
8358 {
8359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8360 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8361 VOS_ASSERT(0);
8362 return VOS_STATUS_E_NOMEM;
8363 }
8364 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8365 if(NULL == pWdaParams)
8366 {
8367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8368 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8369 VOS_ASSERT(0);
8370 vos_mem_free(wdiEnterUapsdReqParams);
8371 return VOS_STATUS_E_NOMEM;
8372 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8373 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8374 pEnterUapsdReqParams->beDeliveryEnabled;
8375 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8376 pEnterUapsdReqParams->beTriggerEnabled;
8377 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8378 pEnterUapsdReqParams->bkDeliveryEnabled;
8379 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8380 pEnterUapsdReqParams->bkTriggerEnabled;
8381 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8382 pEnterUapsdReqParams->viDeliveryEnabled;
8383 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8384 pEnterUapsdReqParams->viTriggerEnabled;
8385 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8386 pEnterUapsdReqParams->voDeliveryEnabled;
8387 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8388 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8389 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8390
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8391 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8392 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8393
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8394 /* Store param pointer as passed in by caller */
8395 /* store Params pass it to WDI */
8396 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8397 pWdaParams->pWdaContext = pWDA;
8398 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8399 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8400 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8401 if(IS_WDI_STATUS_FAILURE(status))
8402 {
8403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8404 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8405 vos_mem_free(pWdaParams->wdaMsgParam) ;
8406 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8407 vos_mem_free(pWdaParams) ;
8408 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8409 return CONVERT_WDI2VOS_STATUS(status) ;
8410}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8411/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8412 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8413 * send Exit UAPSD RSP back to PE
8414 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8415void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8416{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8417
8418 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8419 tWDA_CbContext *pWDA;
8420 tExitUapsdParams *pExitUapsdRspParams;
8421
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8423 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8424 if(NULL == pWdaParams)
8425 {
8426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8427 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8428 VOS_ASSERT(0);
8429 return;
8430 }
8431
8432 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8433 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8434
8435 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8436 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8437
8438 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8439 vos_mem_free(pWdaParams) ;
8440
8441 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8442 return ;
8443}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8444/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8445 * FUNCTION: WDA_ExitUapsdReqCallback
8446 * Free memory and send Exit UAPSD RSP back to PE.
8447 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8448 */
8449void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8450{
8451 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8452 tWDA_CbContext *pWDA;
8453 tExitUapsdParams *pExitUapsdRspParams;
8454
8455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8456 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8457
8458 if(NULL == pWdaParams)
8459 {
8460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8461 "%s: pWdaParams received NULL", __func__);
8462 VOS_ASSERT(0);
8463 return;
8464 }
8465
8466 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8467 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8468 pExitUapsdRspParams->status = wdiStatus;
8469
8470 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8471 {
8472 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8473 vos_mem_free(pWdaParams);
8474 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8475 }
8476
8477 return;
8478}
8479/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8480 * FUNCTION: WDA_ProcessExitUapsdReq
8481 * Request to WDI to Exit UAPSD power state.
8482 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8483VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8484 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8485{
8486 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8487 tWDA_ReqParams *pWdaParams ;
8488 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8489 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8490 sizeof(WDI_ExitUapsdReqParamsType)) ;
8491
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8493 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8494
8495 if(NULL == wdiExitUapsdReqParams)
8496 {
8497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8498 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8499 VOS_ASSERT(0);
8500 return VOS_STATUS_E_NOMEM;
8501 }
8502 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8503 if(NULL == pWdaParams)
8504 {
8505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8506 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8507 VOS_ASSERT(0);
8508 vos_mem_free(wdiExitUapsdReqParams);
8509 return VOS_STATUS_E_NOMEM;
8510 }
8511
8512 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8513 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8514 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8515
8516 /* Store param pointer as passed in by caller */
8517 /* store Params pass it to WDI */
8518 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8519 pWdaParams->pWdaContext = pWDA;
8520 pWdaParams->wdaMsgParam = pExitUapsdParams;
8521
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8522 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8523 if(IS_WDI_STATUS_FAILURE(status))
8524 {
8525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8526 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8527 vos_mem_free(pWdaParams->wdaMsgParam) ;
8528 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8529 vos_mem_free(pWdaParams) ;
8530
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8531 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8532 return CONVERT_WDI2VOS_STATUS(status) ;
8533}
8534
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8535/*
8536 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8537 *
8538 */
8539void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8540{
8541 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8543 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8544 if(NULL == pWdaParams)
8545 {
8546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8547 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8548 VOS_ASSERT(0) ;
8549 return ;
8550 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8551 if( pWdaParams != NULL )
8552 {
8553 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8554 {
8555 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8556 }
8557 if( pWdaParams->wdaMsgParam != NULL )
8558 {
8559 vos_mem_free(pWdaParams->wdaMsgParam) ;
8560 }
8561 vos_mem_free(pWdaParams) ;
8562 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8563 return ;
8564}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8565/*
8566 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8567 * Request to WDI to set the power save params at start.
8568 */
8569VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8570 tSirPowerSaveCfg *pPowerSaveCfg)
8571{
8572 WDI_Status status = WDI_STATUS_SUCCESS ;
8573 tHalCfg *tlvStruct = NULL ;
8574 tANI_U8 *tlvStructStart = NULL ;
8575 v_PVOID_t *configParam;
8576 tANI_U32 configParamSize;
8577 tANI_U32 *configDataValue;
8578 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8579 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8581 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8582 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8583 {
8584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8585 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8586 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8587 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8588 return VOS_STATUS_E_FAILURE;
8589 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8590 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8591 if (NULL == wdiPowerSaveCfg)
8592 {
8593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8594 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8595 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8596 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8597 return VOS_STATUS_E_NOMEM;
8598 }
8599 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8600 if(NULL == pWdaParams)
8601 {
8602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8603 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8604 VOS_ASSERT(0);
8605 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8606 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8607 return VOS_STATUS_E_NOMEM;
8608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8609 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8610 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8611 if(NULL == configParam)
8612 {
8613 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8614 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8615 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8616 vos_mem_free(pWdaParams);
8617 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8618 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8619 return VOS_STATUS_E_NOMEM;
8620 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8621 vos_mem_set(configParam, configParamSize, 0);
8622 wdiPowerSaveCfg->pConfigBuffer = configParam;
8623 tlvStruct = (tHalCfg *)configParam;
8624 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8625 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8626 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8627 tlvStruct->length = sizeof(tANI_U32);
8628 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8629 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8630 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8631 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8632 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8633 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8634 tlvStruct->length = sizeof(tANI_U32);
8635 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8636 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8637 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8638 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8639 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8640 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8641 tlvStruct->length = sizeof(tANI_U32);
8642 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8643 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8644 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8645 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8646 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8647 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8648 tlvStruct->length = sizeof(tANI_U32);
8649 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8650 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8651 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8652 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8653 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8654 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8655 tlvStruct->length = sizeof(tANI_U32);
8656 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8657 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8658 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8659 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8660 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8661 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8662 tlvStruct->length = sizeof(tANI_U32);
8663 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8664 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8665 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8666 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8667 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8668 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8669 tlvStruct->length = sizeof(tANI_U32);
8670 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8671 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8672 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8673 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8674 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8675 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8676 tlvStruct->length = sizeof(tANI_U32);
8677 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8678 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8679 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8680 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8681 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8682 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8683 tlvStruct->length = sizeof(tANI_U32);
8684 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8685 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8686 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8687 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8688 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8689 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8690 tlvStruct->length = sizeof(tANI_U32);
8691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8692 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8693 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8694 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8695 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8696 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8697 tlvStruct->length = sizeof(tANI_U32);
8698 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8699 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8700 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8701 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8702 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8703 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8704 /* store Params pass it to WDI */
8705 pWdaParams->wdaMsgParam = configParam;
8706 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8707 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8708 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8709 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8710 if(IS_WDI_STATUS_FAILURE(status))
8711 {
8712 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8713 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8714 vos_mem_free(pWdaParams->wdaMsgParam);
8715 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8716 vos_mem_free(pWdaParams);
8717 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8718 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8719 return CONVERT_WDI2VOS_STATUS(status);
8720}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8721/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8722 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8723 *
8724 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8725void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8726{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8727 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8728
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8730 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8731
8732 if(NULL == pWdaParams)
8733 {
8734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8735 "%s: pWdaParams received NULL", __func__);
8736 VOS_ASSERT(0);
8737 return ;
8738 }
8739
8740 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8741 vos_mem_free(pWdaParams);
8742
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8743 return ;
8744}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8745/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8746 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8747 * Free memory.
8748 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8749 */
8750void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8751{
8752 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8753
8754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8755 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8756
8757 if(NULL == pWdaParams)
8758 {
8759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8760 "%s: pWdaParams received NULL", __func__);
8761 VOS_ASSERT(0);
8762 return;
8763 }
8764
8765 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8766 {
8767 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8768 vos_mem_free(pWdaParams);
8769 }
8770
8771 return;
8772}
8773/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8774 * FUNCTION: WDA_SetUapsdAcParamsReq
8775 * Request to WDI to set the UAPSD params for an ac (sta mode).
8776 */
8777VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8778 tUapsdInfo *pUapsdInfo)
8779{
8780 WDI_Status status = WDI_STATUS_SUCCESS;
8781 tWDA_CbContext *pWDA = NULL ;
8782 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8783 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8784 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8785 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8787 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8788 if(NULL == wdiUapsdParams)
8789 {
8790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8791 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8792 VOS_ASSERT(0);
8793 return VOS_STATUS_E_NOMEM;
8794 }
8795 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8796 if(NULL == pWdaParams)
8797 {
8798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8799 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8800 VOS_ASSERT(0);
8801 vos_mem_free(wdiUapsdParams);
8802 return VOS_STATUS_E_NOMEM;
8803 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8804 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8805 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8806 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8807 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8808 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8809 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8810 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8811 wdiUapsdParams->pUserData = pWdaParams;
8812
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8813 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8814 pWdaParams->pWdaContext = pWDA;
8815 /* Store param pointer as passed in by caller */
8816 pWdaParams->wdaMsgParam = pUapsdInfo;
8817 /* store Params pass it to WDI */
8818 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8819 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8820 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8821 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8822 if(IS_WDI_STATUS_FAILURE(status))
8823 {
8824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8825 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8826 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8827 vos_mem_free(pWdaParams);
8828 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8829 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8830 return VOS_STATUS_SUCCESS;
8831 else
8832 return VOS_STATUS_E_FAILURE;
8833
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8834}
8835/*
8836 * FUNCTION: WDA_ClearUapsdAcParamsReq
8837 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8838 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8839 * and again enter the UPASD with the modified params. Hence the disable
8840 * function was kept empty.
8841 *
8842 */
8843VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8844{
8845 /* do nothing */
8846 return VOS_STATUS_SUCCESS;
8847}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8848/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8849 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8850 *
8851 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8852void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8853{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8854 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8855
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8856 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8857 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8858
8859 if(NULL == pWdaParams)
8860 {
8861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8862 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8863 VOS_ASSERT(0) ;
8864 return ;
8865 }
8866
8867 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8868 vos_mem_free(pWdaParams->wdaMsgParam);
8869 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8870
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8871 //print a msg, nothing else to do
8872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8873 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8874 return ;
8875}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8876/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8877 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8878 * Free memory.
8879 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8880 */
8881void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8882{
8883 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8884
8885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8886 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8887
8888 if(NULL == pWdaParams)
8889 {
8890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8891 "%s: pWdaParams received NULL", __func__);
8892 VOS_ASSERT(0);
8893 return;
8894 }
8895
8896 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8897 {
8898 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8899 vos_mem_free(pWdaParams->wdaMsgParam);
8900 vos_mem_free(pWdaParams);
8901 }
8902
8903 return;
8904}
8905/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8906 * FUNCTION: WDA_UpdateUapsdParamsReq
8907 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8908 */
8909VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8910 tUpdateUapsdParams* pUpdateUapsdInfo)
8911{
8912 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8913 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8914 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8915 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8916 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8917 tWDA_ReqParams *pWdaParams = NULL;
8918
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8920 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8921 if(NULL == wdiUpdateUapsdParams)
8922 {
8923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8924 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8925 VOS_ASSERT(0);
8926 return VOS_STATUS_E_NOMEM;
8927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8928 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8929 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8930 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8931 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8932 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8933
8934 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8935 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8936 {
8937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8938 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8939 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8940 vos_mem_free(pUpdateUapsdInfo);
8941 vos_mem_free(wdiUpdateUapsdParams);
8942 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8943 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8944 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8945 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8946 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8947 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8948 pWdaParams->pWdaContext = pWDA;
8949
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8950 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8951 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8952 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8953
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8954 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8955 {
8956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8957 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8958 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8959 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8960 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8961 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8962 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8963 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8964}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8965/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8966 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8967 *
8968 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8969void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8970{
8971 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8973 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8974 if(WDI_STATUS_SUCCESS != wdiStatus)
8975 {
8976 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8977 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8978 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8979 if(NULL == pWdaParams)
8980 {
8981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8982 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8983 VOS_ASSERT(0) ;
8984 return ;
8985 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8986 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8987 vos_mem_free(pWdaParams->wdaMsgParam);
8988 vos_mem_free(pWdaParams);
8989 return ;
8990}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8991/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8992 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8993 * Free memory.
8994 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8995 */
8996void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8997{
8998 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8999
9000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9001 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9002
9003 if(NULL == pWdaParams)
9004 {
9005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9006 "%s: pWdaParams received NULL", __func__);
9007 VOS_ASSERT(0);
9008 return;
9009 }
9010
9011 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9012 {
9013 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9014 vos_mem_free(pWdaParams->wdaMsgParam);
9015 vos_mem_free(pWdaParams);
9016 }
9017
9018 return;
9019}
9020/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9021 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
9022 *
9023 */
9024VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
9025 tSirWlanSetRxpFilters *pWlanSuspendParam)
9026{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9027 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9028 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9029 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9030 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9031 /* Sanity Check
9032 * This is very unlikely and add assert to collect more info next time */
9033 if(NULL == pWlanSuspendParam)
9034 {
9035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9036 "%s: pWlanSuspendParam received NULL", __func__);
9037 VOS_ASSERT(0) ;
9038 return VOS_STATUS_E_FAULT;
9039 }
9040 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
9041 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9043 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9044 if(NULL == wdiRxpFilterParams)
9045 {
9046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9047 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9048 VOS_ASSERT(0);
9049 vos_mem_free(pWlanSuspendParam);
9050 return VOS_STATUS_E_NOMEM;
9051 }
9052 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9053 if(NULL == pWdaParams)
9054 {
9055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9056 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9057 VOS_ASSERT(0);
9058 vos_mem_free(wdiRxpFilterParams);
9059 vos_mem_free(pWlanSuspendParam);
9060 return VOS_STATUS_E_NOMEM;
9061 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9062 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
9063 pWlanSuspendParam->setMcstBcstFilter;
9064 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
9065 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9066
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9067 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
9068 wdiRxpFilterParams->pUserData = pWdaParams;
9069
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9070 pWdaParams->pWdaContext = pWDA;
9071 pWdaParams->wdaMsgParam = pWlanSuspendParam;
9072 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9073 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9074 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9075 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9076 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9077 {
9078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9079 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9080 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9081 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9082 vos_mem_free(pWdaParams->wdaMsgParam);
9083 vos_mem_free(pWdaParams);
9084 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9085 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9087/*
9088 * FUNCTION: WDA_WdiIndicationCallback
9089 *
9090 */
9091void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
9092 void* pUserData)
9093{
9094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9095 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9096}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9097/*
9098 * FUNCTION: WDA_ProcessWlanSuspendInd
9099 *
9100 */
9101VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
9102 tSirWlanSuspendParam *pWlanSuspendParam)
9103{
9104 WDI_Status wdiStatus;
9105 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9107 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9108 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
9109 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9110 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
9111 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9112 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]9113 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
9114 if(WDI_STATUS_PENDING == wdiStatus)
9115 {
9116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9117 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9118 }
9119 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9120 {
9121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9122 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9124 vos_mem_free(pWlanSuspendParam);
9125 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9126}
9127
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]9128#ifdef WLAN_FEATURE_11W
9129/*
9130 * FUNCTION: WDA_ProcessExcludeUnecryptInd
9131 *
9132 */
9133VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
9134 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
9135{
9136 WDI_Status wdiStatus;
9137 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
9138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9139 "------> %s ", __func__);
9140
9141 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
9142 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
9143 sizeof(tSirMacAddr));
9144
9145 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
9146 wdiExclUnencryptParams.pUserData = pWDA;
9147
9148 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
9149 if(WDI_STATUS_PENDING == wdiStatus)
9150 {
9151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9152 "Pending received for %s:%d ", __func__, __LINE__ );
9153 }
9154 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9155 {
9156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9157 "Failure in %s:%d ", __func__, __LINE__ );
9158 }
9159 vos_mem_free(pExclUnencryptParam);
9160 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9161}
9162#endif
9163
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9164/*
9165 * FUNCTION: WDA_ProcessWlanResumeCallback
9166 *
9167 */
9168void WDA_ProcessWlanResumeCallback(
9169 WDI_SuspendResumeRspParamsType *resumeRspParams,
9170 void* pUserData)
9171{
9172 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9174 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9175 if(NULL == pWdaParams)
9176 {
9177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9178 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9179 VOS_ASSERT(0) ;
9180 return ;
9181 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9182 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
9183 {
9184 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9185 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9186 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9188 vos_mem_free(pWdaParams->wdaMsgParam);
9189 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9190 return ;
9191}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9192/*
9193 * FUNCTION: WDA_ProcessWlanResumeReq
9194 *
9195 */
9196VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
9197 tSirWlanResumeParam *pWlanResumeParam)
9198{
9199 WDI_Status wdiStatus;
9200 WDI_ResumeParamsType *wdiResumeParams =
9201 (WDI_ResumeParamsType *)vos_mem_malloc(
9202 sizeof(WDI_ResumeParamsType) ) ;
9203 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9205 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9206 if(NULL == wdiResumeParams)
9207 {
9208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9209 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9210 VOS_ASSERT(0);
9211 return VOS_STATUS_E_NOMEM;
9212 }
9213 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9214 if(NULL == pWdaParams)
9215 {
9216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9217 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9218 VOS_ASSERT(0);
9219 vos_mem_free(wdiResumeParams);
9220 return VOS_STATUS_E_NOMEM;
9221 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9222 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
9223 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9224 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]9225 wdiResumeParams->wdiReqStatusCB = NULL;
9226 pWdaParams->wdaMsgParam = pWlanResumeParam;
9227 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
9228 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9229 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
9230 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
9231 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9232 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9233 {
9234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9235 "Failure in Host Resume REQ WDI API, free all the memory " );
9236 VOS_ASSERT(0);
9237 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9238 vos_mem_free(pWdaParams->wdaMsgParam);
9239 vos_mem_free(pWdaParams);
9240 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9241 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9242}
9243
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9244/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9245 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9246 *
9247 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9248void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9249{
9250 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9252 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9253 if(NULL == pWdaParams)
9254 {
9255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9256 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9257 VOS_ASSERT(0) ;
9258 return ;
9259 }
9260
9261 vos_mem_free(pWdaParams->wdaMsgParam) ;
9262 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9263 vos_mem_free(pWdaParams) ;
9264 /*
9265 * No respone required for SetBeaconFilter req so just free the request
9266 * param here
9267 */
9268
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9269 return ;
9270}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9271/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9272 * FUNCTION: WDA_SetBeaconFilterReqCallback
9273 * Free memory.
9274 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
9275 */
9276void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9277{
9278 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9279
9280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9281 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9282
9283 if(NULL == pWdaParams)
9284 {
9285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9286 "%s: pWdaParams received NULL", __func__);
9287 VOS_ASSERT(0);
9288 return;
9289 }
9290
9291 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9292 {
9293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9294 vos_mem_free(pWdaParams->wdaMsgParam);
9295 vos_mem_free(pWdaParams);
9296 }
9297
9298 return;
9299}
9300/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9301 * FUNCTION: WDA_SetBeaconFilterReq
9302 * Request to WDI to send the beacon filtering related information.
9303 */
9304VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9305 tBeaconFilterMsg* pBeaconFilterInfo)
9306{
9307 WDI_Status status = WDI_STATUS_SUCCESS;
9308 tANI_U8 *dstPtr, *srcPtr;
9309 tANI_U8 filterLength;
9310 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9311 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9312 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9313 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9315 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9316 if(NULL == wdiBeaconFilterInfo)
9317 {
9318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9319 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9320 VOS_ASSERT(0);
9321 return VOS_STATUS_E_NOMEM;
9322 }
9323 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9324 if(NULL == pWdaParams)
9325 {
9326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9327 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9328 VOS_ASSERT(0);
9329 vos_mem_free(wdiBeaconFilterInfo);
9330 return VOS_STATUS_E_NOMEM;
9331 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9332 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9333 pBeaconFilterInfo->beaconInterval;
9334 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9335 pBeaconFilterInfo->capabilityInfo;
9336 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9337 pBeaconFilterInfo->capabilityMask;
9338 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9339
9340 //Fill the BssIdx
9341 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9342
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9343 //Fill structure with info contained in the beaconFilterTable
9344 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9345 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9346 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9347 if(WDI_BEACON_FILTER_LEN < filterLength)
9348 {
9349 filterLength = WDI_BEACON_FILTER_LEN;
9350 }
9351 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9352 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9353 wdiBeaconFilterInfo->pUserData = pWdaParams;
9354
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9355 /* Store param pointer as passed in by caller */
9356 /* store Params pass it to WDI */
9357 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9358 pWdaParams->pWdaContext = pWDA;
9359 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9360
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9361 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9362 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9363 if(IS_WDI_STATUS_FAILURE(status))
9364 {
9365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9366 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9367 vos_mem_free(pWdaParams->wdaMsgParam) ;
9368 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9369 vos_mem_free(pWdaParams) ;
9370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9371 return CONVERT_WDI2VOS_STATUS(status) ;
9372}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9373/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9374 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9375 *
9376 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9377void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9378{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9379 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9380
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9382 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9383
9384 if(NULL == pWdaParams)
9385 {
9386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9387 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9388 VOS_ASSERT(0) ;
9389 return ;
9390 }
9391
9392 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9393 vos_mem_free(pWdaParams->wdaMsgParam);
9394 vos_mem_free(pWdaParams);
9395
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9396 //print a msg, nothing else to do
9397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9398 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9399 return ;
9400}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9401/*
9402 * FUNCTION: WDA_RemBeaconFilterReqCallback
9403 * Free memory.
9404 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9405 */
9406void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9407{
9408 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9409
9410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9411 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9412
9413 if(NULL == pWdaParams)
9414 {
9415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9416 "%s: pWdaParams received NULL", __func__);
9417 VOS_ASSERT(0);
9418 return;
9419 }
9420
9421 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9422 {
9423 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9424 vos_mem_free(pWdaParams->wdaMsgParam);
9425 vos_mem_free(pWdaParams);
9426 }
9427
9428 return;
9429}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9430 // TODO: PE does not have this feature for now implemented,
9431 // but the support for removing beacon filter exists between
9432 // HAL and FW. This function can be called whenever PE defines
9433 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9434/*
9435 * FUNCTION: WDA_RemBeaconFilterReq
9436 * Request to WDI to send the removal of beacon filtering related information.
9437 */
9438VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9439 tRemBeaconFilterMsg* pBeaconFilterInfo)
9440{
9441 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9442 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9443 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9444 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9445 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9446 tWDA_ReqParams *pWdaParams ;
9447
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9449 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9450 if(NULL == wdiBeaconFilterInfo)
9451 {
9452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9453 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9454 VOS_ASSERT(0);
9455 return VOS_STATUS_E_NOMEM;
9456 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9457 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9458 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9459 {
9460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9461 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9462 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9463 vos_mem_free(wdiBeaconFilterInfo);
9464 vos_mem_free(pBeaconFilterInfo);
9465 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9466 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9467
9468 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9469 pBeaconFilterInfo->ucIeCount;
9470 //Fill structure with info contained in the ucRemIeId
9471 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9472 pBeaconFilterInfo->ucRemIeId,
9473 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9474 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9475 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9476
9477 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9478 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9479 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9480 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9481
9482 pWdaParams->pWdaContext = pWDA;
9483
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9484 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9485 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9486 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9487 {
9488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9489 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9490 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9491 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9492 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9493 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9494 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9495 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9496}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9497/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9498 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9499 *
9500 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9501void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9502{
9503 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9505 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9506 if(NULL == pWdaParams)
9507 {
9508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9509 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9510 VOS_ASSERT(0) ;
9511 return ;
9512 }
9513
9514 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9515 vos_mem_free(pWdaParams) ;
9516
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9517 return ;
9518}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9519/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9520 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9521 * Free memory.
9522 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9523 */
9524void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9525{
9526 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9527
9528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9529 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9530
9531 if(NULL == pWdaParams)
9532 {
9533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9534 "%s: pWdaParams received NULL", __func__);
9535 VOS_ASSERT(0);
9536 return;
9537 }
9538
9539 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9540 {
9541 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9542 vos_mem_free(pWdaParams);
9543 }
9544
9545 return;
9546}
9547/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9548 * FUNCTION: WDA_SetRSSIThresholdsReq
9549 * Request to WDI to set the RSSI thresholds (sta mode).
9550 */
9551VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9552{
9553 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9554 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555 tWDA_CbContext *pWDA = NULL ;
9556 v_PVOID_t pVosContext = NULL;
9557 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9558 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9559 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9560 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9562 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9563 if(NULL == wdiRSSIThresholdsInfo)
9564 {
9565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9566 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9567 VOS_ASSERT(0);
9568 return VOS_STATUS_E_NOMEM;
9569 }
9570 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9571 if(NULL == pWdaParams)
9572 {
9573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9574 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9575 VOS_ASSERT(0);
9576 vos_mem_free(wdiRSSIThresholdsInfo);
9577 return VOS_STATUS_E_NOMEM;
9578 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9579 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9580 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9581 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9582 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9583 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9584 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9585 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9586 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9587 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9588 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9589 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9590 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9591 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9592 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9593
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9594 /* Store param pointer as passed in by caller */
9595 /* store Params pass it to WDI */
9596 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9597 pWdaParams->pWdaContext = pWDA;
9598 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9599 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9600 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9601 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9602 {
9603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9604 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9605 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9606 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9607 vos_mem_free(pWdaParams) ;
9608 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9609 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9610
9611}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9612/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9613 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9614 *
9615 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9616void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9617{
9618 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9619
9620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9621 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9622 if(NULL == pWdaParams)
9623 {
9624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9625 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9626 VOS_ASSERT(0) ;
9627 return ;
9628 }
9629
9630 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9631 vos_mem_free(pWdaParams->wdaMsgParam);
9632 vos_mem_free(pWdaParams) ;
9633
9634 //print a msg, nothing else to do
9635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9636 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9637 return ;
9638}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9639/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9640 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9641 * Free memory.
9642 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9643 */
9644void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9645{
9646 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9647
9648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9649 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9650
9651 if(NULL == pWdaParams)
9652 {
9653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9654 "%s: Invalid pWdaParams pointer", __func__);
9655 VOS_ASSERT(0);
9656 return;
9657 }
9658
9659 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9660 {
9661 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9662 vos_mem_free(pWdaParams->wdaMsgParam);
9663 vos_mem_free(pWdaParams);
9664 }
9665
9666 return;
9667}
9668/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9669 * FUNCTION: WDA_ProcessHostOffloadReq
9670 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9671 * to broadcast traffic (sta mode).
9672 */
9673VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9674 tSirHostOffloadReq *pHostOffloadParams)
9675{
9676 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9677 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9678 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9679 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9680 sizeof(WDI_HostOffloadReqParamsType)) ;
9681 tWDA_ReqParams *pWdaParams ;
9682
9683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9684 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9685
9686 if(NULL == wdiHostOffloadInfo)
9687 {
9688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9689 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9690 VOS_ASSERT(0);
9691 return VOS_STATUS_E_NOMEM;
9692 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9693 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9694 if(NULL == pWdaParams)
9695 {
9696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9697 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9698 VOS_ASSERT(0);
9699 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9700 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9701 return VOS_STATUS_E_NOMEM;
9702 }
9703
9704 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9705 pHostOffloadParams->offloadType;
9706 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9707 pHostOffloadParams->enableOrDisable;
9708
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9709 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9710 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9711
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9712 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9713 {
9714 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9715 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9716 pHostOffloadParams->params.hostIpv4Addr,
9717 4);
9718 break;
9719 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9720 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9721 pHostOffloadParams->params.hostIpv6Addr,
9722 16);
9723 break;
9724 case SIR_IPV6_NS_OFFLOAD:
9725 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9726 pHostOffloadParams->params.hostIpv6Addr,
9727 16);
9728
9729#ifdef WLAN_NS_OFFLOAD
9730 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9731 {
9732 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9733 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9734 16);
9735 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9736 }
9737 else
9738 {
9739 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9740 }
9741
9742 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9743 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9744 16);
9745 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9746 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9747 6);
9748
9749 //Only two are supported so let's go through them without a loop
9750 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9751 {
9752 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9753 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9754 16);
9755 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9756 }
9757 else
9758 {
9759 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9760 }
9761
9762 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9763 {
9764 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9765 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9766 16);
9767 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9768 }
9769 else
9770 {
9771 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9772 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9773 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9774 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9775 break;
9776#endif //WLAN_NS_OFFLOAD
9777 default:
9778 {
9779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9780 "No Handling for Offload Type %x in WDA "
9781 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9782 //WDA_VOS_ASSERT(0) ;
9783 }
9784 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9785 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9786 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9787
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9788 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9789 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9790 /* store Params pass it to WDI */
9791 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9792 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9793
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9794
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9795 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9796 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9797
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9798 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9799 {
9800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9801 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9802 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9803 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9804 vos_mem_free(pWdaParams->wdaMsgParam);
9805 vos_mem_free(pWdaParams) ;
9806 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9807 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9808
9809}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9810/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9811 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9812 *
9813 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9814void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9815{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9816 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9817
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9819 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9820
9821 if(NULL == pWdaParams)
9822 {
9823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9824 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9825 VOS_ASSERT(0) ;
9826 return ;
9827 }
9828
9829 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9830 vos_mem_free(pWdaParams->wdaMsgParam);
9831 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9832
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9833 //print a msg, nothing else to do
9834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9835 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9836 return ;
9837}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9838/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9839 * FUNCTION: WDA_KeepAliveReqCallback
9840 * Free memory.
9841 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9842 */
9843void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9844{
9845 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9846
9847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9848 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9849
9850 if(NULL == pWdaParams)
9851 {
9852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9853 "%s: pWdaParams received NULL", __func__);
9854 VOS_ASSERT(0);
9855 return;
9856 }
9857
9858 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9859 {
9860 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9861 vos_mem_free(pWdaParams->wdaMsgParam);
9862 vos_mem_free(pWdaParams);
9863 }
9864
9865 return;
9866}
9867/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9868 * FUNCTION: WDA_ProcessKeepAliveReq
9869 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9870 * wakeup due to broadcast traffic (sta mode).
9871 */
9872VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9873 tSirKeepAliveReq *pKeepAliveParams)
9874{
9875 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9876 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9877 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9878 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9879 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9880 tWDA_ReqParams *pWdaParams;
9881
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9883 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9884 if(NULL == wdiKeepAliveInfo)
9885 {
9886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9887 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9888 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9889 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9890 return VOS_STATUS_E_NOMEM;
9891 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9892
9893 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9894 if(NULL == pWdaParams)
9895 {
9896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9897 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9898 VOS_ASSERT(0);
9899 vos_mem_free(wdiKeepAliveInfo);
9900 vos_mem_free(pKeepAliveParams);
9901 return VOS_STATUS_E_NOMEM;
9902 }
9903
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9904 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9905 pKeepAliveParams->packetType;
9906 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9907 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9908
9909 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9910 pKeepAliveParams->bssId,
9911 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9912
9913 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9914 {
9915 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9916 pKeepAliveParams->hostIpv4Addr,
9917 SIR_IPV4_ADDR_LEN);
9918 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9919 pKeepAliveParams->destIpv4Addr,
9920 SIR_IPV4_ADDR_LEN);
9921 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9922 pKeepAliveParams->destMacAddr,
9923 SIR_MAC_ADDR_LEN);
9924 }
9925 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9926 {
9927 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9928 SIR_IPV4_ADDR_LEN,
9929 0);
9930 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9931 SIR_IPV4_ADDR_LEN,
9932 0);
9933 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9934 SIR_MAC_ADDR_LEN,
9935 0);
9936 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9937 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9938 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9939
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9940 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9941 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9942 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9943 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9944 pWdaParams->pWdaContext = pWDA;
9945
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9947 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9948 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9949 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9950 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9952 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9953 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9954 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9955 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9957 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9958 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9959 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9960 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9961 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9962 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9963 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9965 "TimePeriod %d PacketType %d",
9966 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9967 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9968 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9969 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9970
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9971 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9972 {
9973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9974 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9975 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9976 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9977 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9978 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9979 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9980 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9981
9982}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9983/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9984 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9985 *
9986 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9987void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9988 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9989 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9990{
9991 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9993 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9994 if(NULL == pWdaParams)
9995 {
9996 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9997 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9998 VOS_ASSERT(0) ;
9999 return ;
10000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10001 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10002 vos_mem_free(pWdaParams->wdaMsgParam);
10003 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10004 return ;
10005}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10006/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10007 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
10008 * Free memory.
10009 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
10010 */
10011void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10012{
10013 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10014
10015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10016 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10017
10018 if(NULL == pWdaParams)
10019 {
10020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10021 "%s: pWdaParams received NULL", __func__);
10022 VOS_ASSERT(0);
10023 return;
10024 }
10025
10026 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10027 {
10028 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10029 vos_mem_free(pWdaParams->wdaMsgParam);
10030 vos_mem_free(pWdaParams);
10031 }
10032
10033 return;
10034}
10035
10036/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10037 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
10038 * Request to WDI to add WOWL Bcast pattern
10039 */
10040VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
10041 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
10042{
10043 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10044 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10045 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
10046 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
10047 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
10048 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10050 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10051 if(NULL == wdiWowlAddBcPtrnInfo)
10052 {
10053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10054 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10055 VOS_ASSERT(0);
10056 return VOS_STATUS_E_NOMEM;
10057 }
10058 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10059 if(NULL == pWdaParams)
10060 {
10061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10062 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10063 VOS_ASSERT(0);
10064 vos_mem_free(wdiWowlAddBcPtrnInfo);
10065 return VOS_STATUS_E_NOMEM;
10066 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
10068 pWowlAddBcPtrnParams->ucPatternId;
10069 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
10070 pWowlAddBcPtrnParams->ucPatternByteOffset;
10071 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
10072 pWowlAddBcPtrnParams->ucPatternMaskSize;
10073 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
10074 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10075 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
10076 {
10077 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10078 pWowlAddBcPtrnParams->ucPattern,
10079 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
10080 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10081 pWowlAddBcPtrnParams->ucPatternMask,
10082 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
10083 }
10084 else
10085 {
10086 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10087 pWowlAddBcPtrnParams->ucPattern,
10088 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10089 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10090 pWowlAddBcPtrnParams->ucPatternMask,
10091 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10092
10093 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
10094 pWowlAddBcPtrnParams->ucPatternExt,
10095 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10096 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
10097 pWowlAddBcPtrnParams->ucPatternMaskExt,
10098 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10099 }
10100
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10101 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
10102 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
10103
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10104 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
10105 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10106 /* Store param pointer as passed in by caller */
10107 /* store Params pass it to WDI */
10108 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
10109 pWdaParams->pWdaContext = pWDA;
10110 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10111 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10112 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10113 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10114 {
10115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10116 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10117 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10118 vos_mem_free(pWdaParams->wdaMsgParam) ;
10119 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10120 vos_mem_free(pWdaParams) ;
10121 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10122 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10123
10124}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10125/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10126 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10127 *
10128 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10129void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10130 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
10131 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10132{
10133 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10135 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10136 if(NULL == pWdaParams)
10137 {
10138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10139 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10140 VOS_ASSERT(0) ;
10141 return ;
10142 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10143 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10144 vos_mem_free(pWdaParams->wdaMsgParam);
10145 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10146 return ;
10147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10148/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10149 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
10150 * Free memory.
10151 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
10152 */
10153void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10154{
10155 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10156
10157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10158 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10159
10160 if(NULL == pWdaParams)
10161 {
10162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10163 "%s: pWdaParams received NULL", __func__);
10164 VOS_ASSERT(0);
10165 return;
10166 }
10167
10168 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10169 {
10170 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10171 vos_mem_free(pWdaParams->wdaMsgParam);
10172 vos_mem_free(pWdaParams);
10173 }
10174
10175 return;
10176}
10177/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10178 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
10179 * Request to WDI to delete WOWL Bcast pattern
10180 */
10181VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
10182 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
10183{
10184 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10185 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10186 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
10187 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
10188 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
10189 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10191 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10192 if(NULL == wdiWowlDelBcPtrnInfo)
10193 {
10194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10195 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10196 VOS_ASSERT(0);
10197 return VOS_STATUS_E_NOMEM;
10198 }
10199 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10200 if(NULL == pWdaParams)
10201 {
10202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10203 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10204 VOS_ASSERT(0);
10205 vos_mem_free(wdiWowlDelBcPtrnInfo);
10206 return VOS_STATUS_E_NOMEM;
10207 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10208 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
10209 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10210
10211 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
10212 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
10213
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10214 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
10215 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10216 /* Store param pointer as passed in by caller */
10217 /* store Params pass it to WDI */
10218 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
10219 pWdaParams->pWdaContext = pWDA;
10220 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10221 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10222 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10223 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10224 {
10225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10226 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10227 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10228 vos_mem_free(pWdaParams->wdaMsgParam) ;
10229 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10230 vos_mem_free(pWdaParams) ;
10231 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10232 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10233
10234}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10235/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10236 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10237 *
10238 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10239void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10240{
10241 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10242 tWDA_CbContext *pWDA;
10243 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10244 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10245 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10246 if(NULL == pWdaParams)
10247 {
10248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10249 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10250 VOS_ASSERT(0) ;
10251 return ;
10252 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10253 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10254 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
10255
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10256 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
10257
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10258 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10259 vos_mem_free(pWdaParams) ;
10260
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10261 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10262 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10263 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10264 return ;
10265}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10266/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10267 * FUNCTION: WDA_WowlEnterReqCallback
10268 * Free memory and send WOWL Enter RSP back to PE.
10269 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
10270 */
10271void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
10272{
10273 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10274 tWDA_CbContext *pWDA;
10275 tSirHalWowlEnterParams *pWowlEnterParams;
10276
10277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10278 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10279
10280 if(NULL == pWdaParams)
10281 {
10282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10283 "%s: pWdaParams received NULL", __func__);
10284 VOS_ASSERT(0);
10285 return;
10286 }
10287
10288 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10289 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10290 pWowlEnterParams->status = wdiStatus;
10291
10292 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10293 {
10294 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10295 vos_mem_free(pWdaParams);
10296 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10297 }
10298
10299 return;
10300}
10301/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10302 * FUNCTION: WDA_ProcessWowlEnterReq
10303 * Request to WDI to enter WOWL
10304 */
10305VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10306 tSirHalWowlEnterParams *pWowlEnterParams)
10307{
10308 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10309 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10310 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10311 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10312 sizeof(WDI_WowlEnterReqParamsType)) ;
10313 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10315 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10316 if(NULL == wdiWowlEnterInfo)
10317 {
10318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10319 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10320 VOS_ASSERT(0);
10321 return VOS_STATUS_E_NOMEM;
10322 }
10323 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10324 if(NULL == pWdaParams)
10325 {
10326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10327 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10328 VOS_ASSERT(0);
10329 vos_mem_free(wdiWowlEnterInfo);
10330 return VOS_STATUS_E_NOMEM;
10331 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10332
10333 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10334
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10335 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10336 pWowlEnterParams->magicPtrn,
10337 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10338 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10339 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10340 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10341 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10342 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10343 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10344 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10345 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10346 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10347 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10348 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10349 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10350 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10351 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10352 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10353 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10354#ifdef WLAN_WAKEUP_EVENTS
10355 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10356 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10357
10358 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10359 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10360
10361 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10362 pWowlEnterParams->ucWowNetScanOffloadMatch;
10363
10364 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10365 pWowlEnterParams->ucWowGTKRekeyError;
10366
10367 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10368 pWowlEnterParams->ucWoWBSSConnLoss;
10369#endif // WLAN_WAKEUP_EVENTS
10370
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10371 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10372 pWowlEnterParams->bssIdx;
10373
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10374 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10375 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10376 /* Store param pointer as passed in by caller */
10377 /* store Params pass it to WDI */
10378 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10379 pWdaParams->pWdaContext = pWDA;
10380 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10381 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10382 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10383 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10384 {
10385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10386 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10387 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10388 vos_mem_free(pWdaParams->wdaMsgParam) ;
10389 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10390 vos_mem_free(pWdaParams) ;
10391 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10392 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10393
10394}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10395/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10396 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10397 *
10398 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10399void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10400{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10401 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10402 tWDA_CbContext *pWDA;
10403 tSirHalWowlExitParams *pWowlExitParams;
10404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10405 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10406 if(NULL == pWdaParams)
10407 {
10408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10409 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10410 VOS_ASSERT(0) ;
10411 return ;
10412 }
10413 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10414 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10415
10416 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10417 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10418
10419 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10420 vos_mem_free(pWdaParams) ;
10421
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]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__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10424 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10425 return ;
10426}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10427/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10428 * FUNCTION: WDA_WowlExitReqCallback
10429 * Free memory and send WOWL Exit RSP back to PE.
10430 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10431 */
10432void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10433{
10434 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10435 tWDA_CbContext *pWDA;
10436 tSirHalWowlExitParams *pWowlExitParams;
10437
10438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10439 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10440
10441 if(NULL == pWdaParams)
10442 {
10443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10444 "%s: pWdaParams received NULL", __func__);
10445 VOS_ASSERT(0);
10446 return;
10447 }
10448
10449 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10450 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10451 pWowlExitParams->status = wdiStatus;
10452
10453 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10454 {
10455 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10456 vos_mem_free(pWdaParams);
10457 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10458 }
10459
10460 return;
10461}
10462/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10463 * FUNCTION: WDA_ProcessWowlExitReq
10464 * Request to WDI to add WOWL Bcast pattern
10465 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10466VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10467 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10468{
10469 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10470 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10471 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10472 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10473 sizeof(WDI_WowlExitReqParamsType)) ;
10474 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10476 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10477 if(NULL == wdiWowlExitInfo)
10478 {
10479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10480 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10481 VOS_ASSERT(0);
10482 return VOS_STATUS_E_NOMEM;
10483 }
10484 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10485 if(NULL == pWdaParams)
10486 {
10487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10488 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10489 VOS_ASSERT(0);
10490 vos_mem_free(wdiWowlExitInfo);
10491 return VOS_STATUS_E_NOMEM;
10492 }
10493
10494 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10495 pWowlExitParams->bssIdx;
10496
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10497 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10498 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10499
10500 /* Store param pointer as passed in by caller */
10501 /* store Params pass it to WDI */
10502 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10503 pWdaParams->pWdaContext = pWDA;
10504 pWdaParams->wdaMsgParam = pWowlExitParams;
10505
10506 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10507 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10508
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10509 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10510 {
10511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10512 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10513 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10514 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10515 vos_mem_free(pWdaParams->wdaMsgParam);
10516 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10517 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10518 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10519}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10520/*
10521 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10522 * Request to WDI to determine whether a given station is capable of
10523 * using HW-based frame translation
10524 */
10525v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10526 tANI_U8 staIdx)
10527{
10528 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10529}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10530
10531/*
10532 * FUNCTION: WDA_IsSelfSTA
10533 * Request to WDI to determine whether a given STAID is self station
10534 * index.
10535 */
10536v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10537{
10538
10539 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10540
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10541 if (NULL != pWDA)
10542 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10543 else
10544 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10545}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10546/*
10547 * FUNCTION: WDA_NvDownloadReqCallback
10548 * send NV Download RSP back to PE
10549 */
10550void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10551 void* pUserData)
10552{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10553
10554 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10555 tWDA_CbContext *pWDA;
10556
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10558 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10559
10560 if(NULL == pWdaParams)
10561 {
10562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10563 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10564 VOS_ASSERT(0) ;
10565 return ;
10566 }
10567
10568 pWDA = pWdaParams->pWdaContext;
10569
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10570 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10571 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10572 vos_mem_free(pWdaParams);
10573
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10574 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10575 return ;
10576}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10577/*
10578 * FUNCTION: WDA_ProcessNvDownloadReq
10579 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10580 */
10581VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10582{
10583 /* Initialize the local Variables*/
10584 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10585 v_VOID_t *pNvBuffer=NULL;
10586 v_SIZE_t bufferSize = 0;
10587 WDI_Status status = WDI_STATUS_E_FAILURE;
10588 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10589 tWDA_ReqParams *pWdaParams ;
10590
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10592 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10593 if(NULL == pWDA)
10594 {
10595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10596 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10597 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10598 return VOS_STATUS_E_FAILURE;
10599 }
10600
10601 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10602 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10603
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10604 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10605 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10606 if(NULL == wdiNvDownloadReqParam)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10610 VOS_ASSERT(0);
10611 return VOS_STATUS_E_NOMEM;
10612 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10613 /* Copy Params to wdiNvDownloadReqParam*/
10614 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10615 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10616
10617 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10618 if(NULL == pWdaParams)
10619 {
10620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10621 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10622 VOS_ASSERT(0);
10623 vos_mem_free(wdiNvDownloadReqParam);
10624 return VOS_STATUS_E_NOMEM;
10625 }
10626
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10627 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10628 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10629 pWdaParams->wdaMsgParam = NULL;
10630 pWdaParams->pWdaContext = pWDA;
10631
10632
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10633 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10634
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10635 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10636 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10637
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10638 if(IS_WDI_STATUS_FAILURE(status))
10639 {
10640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10641 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10642 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10643 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10644 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10645 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10646}
10647/*
10648 * FUNCTION: WDA_FlushAcReqCallback
10649 * send Flush AC RSP back to TL
10650 */
10651void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10652{
10653 vos_msg_t wdaMsg = {0} ;
10654 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10655 tFlushACReq *pFlushACReqParams;
10656 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10658 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10659 if(NULL == pWdaParams)
10660 {
10661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10662 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10663 VOS_ASSERT(0) ;
10664 return ;
10665 }
10666
10667 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10668 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10669 if(NULL == pFlushACRspParams)
10670 {
10671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10672 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10673 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10674 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10675 return ;
10676 }
10677 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10678 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10679 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10680 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10681 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10682 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10683 vos_mem_free(pWdaParams->wdaMsgParam) ;
10684 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10685 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10686 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10687 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10688 // POST message to TL
10689 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10690
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10691 return ;
10692}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10693/*
10694 * FUNCTION: WDA_ProcessFlushAcReq
10695 * Request to WDI to Update the DELBA REQ params.
10696 */
10697VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10698 tFlushACReq *pFlushAcReqParams)
10699{
10700 WDI_Status status = WDI_STATUS_SUCCESS ;
10701 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10702 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10703 sizeof(WDI_FlushAcReqParamsType)) ;
10704 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10705 if(NULL == wdiFlushAcReqParam)
10706 {
10707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10708 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10709 VOS_ASSERT(0);
10710 return VOS_STATUS_E_NOMEM;
10711 }
10712 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10713 if(NULL == pWdaParams)
10714 {
10715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10716 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10717 VOS_ASSERT(0);
10718 vos_mem_free(wdiFlushAcReqParam);
10719 return VOS_STATUS_E_NOMEM;
10720 }
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 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10724 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10725 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10726 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10727 /* Store Flush AC pointer, as this will be used for response */
10728 /* store Params pass it to WDI */
10729 pWdaParams->pWdaContext = pWDA;
10730 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10731 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10732 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10733 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10734 if(IS_WDI_STATUS_FAILURE(status))
10735 {
10736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10737 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10738 vos_mem_free(pWdaParams->wdaMsgParam) ;
10739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10740 vos_mem_free(pWdaParams) ;
10741 //TODO: respond to TL with failure
10742 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10743 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10744}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10745/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10746 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10747 *
10748 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10749void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10750{
10751 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10752 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10753 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10754
10755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10756 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10757 if(NULL == pWdaParams)
10758 {
10759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10760 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10761 VOS_ASSERT(0) ;
10762 return ;
10763 }
10764 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10765 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10766 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10767 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10768 {
10769 pWDA->wdaAmpSessionOn = VOS_FALSE;
10770 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10771 vos_mem_free(pWdaParams->wdaMsgParam) ;
10772 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10773 vos_mem_free(pWdaParams) ;
10774 /*
10775 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10776 * param here
10777 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10778 return ;
10779}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10780/*
10781 * FUNCTION: WDA_BtAmpEventReqCallback
10782 * Free memory.
10783 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10784 */
10785void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10786{
10787 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10788 tWDA_CbContext *pWDA;
10789 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10790
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10792 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10793
10794 if(NULL == pWdaParams)
10795 {
10796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10797 "%s: pWdaParams received NULL", __func__);
10798 VOS_ASSERT(0);
10799 return;
10800 }
10801
10802 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10803 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10804
10805 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10806 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10807 {
10808 pWDA->wdaAmpSessionOn = VOS_FALSE;
10809 }
10810
10811 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10812 {
10813 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10814 vos_mem_free(pWdaParams->wdaMsgParam);
10815 vos_mem_free(pWdaParams);
10816 }
10817
10818 return;
10819}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10820/*
10821 * FUNCTION: WDA_ProcessBtAmpEventReq
10822 * Request to WDI to Update with BT AMP events.
10823 */
10824VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10825 tSmeBtAmpEvent *pBtAmpEventParams)
10826{
10827 WDI_Status status = WDI_STATUS_SUCCESS ;
10828 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10829 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10830 sizeof(WDI_BtAmpEventParamsType)) ;
10831 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10833 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10834 if(NULL == wdiBtAmpEventParam)
10835 {
10836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10837 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10838 VOS_ASSERT(0);
10839 return VOS_STATUS_E_NOMEM;
10840 }
10841 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10842 if(NULL == pWdaParams)
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 vos_mem_free(wdiBtAmpEventParam);
10848 return VOS_STATUS_E_NOMEM;
10849 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10850 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10851 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10852 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10853 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10854 /* Store BT AMP event pointer, as this will be used for response */
10855 /* store Params pass it to WDI */
10856 pWdaParams->pWdaContext = pWDA;
10857 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10858 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10859 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10860 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861 if(IS_WDI_STATUS_FAILURE(status))
10862 {
10863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10864 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10865 vos_mem_free(pWdaParams->wdaMsgParam) ;
10866 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10867 vos_mem_free(pWdaParams) ;
10868 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10869 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10870 {
10871 pWDA->wdaAmpSessionOn = VOS_TRUE;
10872 }
10873 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10874}
10875
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10876/*
10877 * FUNCTION: WDA_FTMCommandReqCallback
10878 * Handle FTM CMD response came from HAL
10879 * Route responce to HDD FTM
10880 */
10881void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10882 void *usrData)
10883{
10884 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10885 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10886 {
10887 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10888 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10889 return;
10890 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10891 /* Release Current FTM Command Request */
10892 vos_mem_free(pWDA->wdaFTMCmdReq);
10893 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10894 /* Post FTM Responce to HDD FTM */
10895 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10896 return;
10897}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10898/*
10899 * FUNCTION: WDA_ProcessFTMCommand
10900 * Send FTM command to WDI
10901 */
10902VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10903 tPttMsgbuffer *pPTTFtmCmd)
10904{
10905 WDI_Status status = WDI_STATUS_SUCCESS;
10906 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10907 ftmCMDReq = (WDI_FTMCommandReqType *)
10908 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10909 if(NULL == ftmCMDReq)
10910 {
10911 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10912 "WDA FTM Command buffer alloc fail");
10913 return VOS_STATUS_E_NOMEM;
10914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10915 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10916 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10917 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10918 /* Send command to WDI */
10919 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10920 return status;
10921}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10922#ifdef FEATURE_OEM_DATA_SUPPORT
10923/*
10924 * FUNCTION: WDA_StartOemDataReqCallback
10925 *
10926 */
10927void WDA_StartOemDataReqCallback(
10928 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10929 void* pUserData)
10930{
10931 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10932 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10933 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10934 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10935
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10937 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10938
10939 if(NULL == pWdaParams)
10940 {
10941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10942 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10943 VOS_ASSERT(0) ;
10944 return ;
10945 }
10946 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10947
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10948 if(NULL == pWDA)
10949 {
10950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10951 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10952 VOS_ASSERT(0);
10953 return ;
10954 }
10955
10956 /*
10957 * Allocate memory for response params sent to PE
10958 */
10959 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10960
10961 // Check if memory is allocated for OemdataMeasRsp Params.
10962 if(NULL == pOemDataRspParams)
10963 {
10964 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10965 "OEM DATA WDA callback alloc fail");
10966 VOS_ASSERT(0) ;
10967 return;
10968 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10969
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10970 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10971 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10972 vos_mem_free(pWdaParams->wdaMsgParam);
10973 vos_mem_free(pWdaParams) ;
10974
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10975 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10976 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10977 * Also, here success always means that we have atleast one BSSID.
10978 */
10979 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10980
10981 //enable Tx
10982 status = WDA_ResumeDataTx(pWDA);
10983 if(status != VOS_STATUS_SUCCESS)
10984 {
10985 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10986 }
10987 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10988 return ;
10989}
10990/*
10991 * FUNCTION: WDA_ProcessStartOemDataReq
10992 * Send Start Oem Data Req to WDI
10993 */
10994VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10995 tStartOemDataReq *pOemDataReqParams)
10996{
10997 WDI_Status status = WDI_STATUS_SUCCESS;
10998 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10999 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11000
11001 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
11002
11003 if(NULL == wdiOemDataReqParams)
11004 {
11005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11006 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11007 VOS_ASSERT(0);
11008 return VOS_STATUS_E_NOMEM;
11009 }
11010
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11011 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
11012 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
11013 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
11014 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11015
11016 wdiOemDataReqParams->wdiReqStatusCB = NULL;
11017
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11018 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11019 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11020 {
11021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11022 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11023 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11024 vos_mem_free(pOemDataReqParams);
11025 VOS_ASSERT(0);
11026 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11027 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11028
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]11029 pWdaParams->pWdaContext = (void*)pWDA;
11030 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
11031 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11032
11033 status = WDI_StartOemDataReq(wdiOemDataReqParams,
11034 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11035
11036 if(IS_WDI_STATUS_FAILURE(status))
11037 {
11038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11039 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11040 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11041 vos_mem_free(pWdaParams->wdaMsgParam);
11042 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11043 }
11044 return CONVERT_WDI2VOS_STATUS(status) ;
11045}
11046#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11047/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11048 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11049 *
11050 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11051void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11052{
11053 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11055 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11056 if(NULL == pWdaParams)
11057 {
11058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11059 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11060 VOS_ASSERT(0) ;
11061 return ;
11062 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11063
11064 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11065 vos_mem_free(pWdaParams->wdaMsgParam);
11066 vos_mem_free(pWdaParams);
11067
11068 return ;
11069}
11070/*
11071 * FUNCTION: WDA_SetTxPerTrackingReqCallback
11072 * Free memory.
11073 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
11074 */
11075void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
11076{
11077 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11078
11079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11080 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11081
11082 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11083 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11085 "%s: pWdaParams received NULL", __func__);
11086 VOS_ASSERT(0);
11087 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11088 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11089
11090 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11091 {
11092 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11093 vos_mem_free(pWdaParams->wdaMsgParam);
11094 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11095 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11096
11097 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11098}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11099#ifdef WLAN_FEATURE_GTK_OFFLOAD
11100/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11101 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11102 *
11103 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11104void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11105 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11106{
11107 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11108
11109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11110 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11111 if(NULL == pWdaParams)
11112 {
11113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11114 "%s: pWdaParams received NULL", __func__);
11115 VOS_ASSERT(0);
11116 return;
11117 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11118
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11119 vos_mem_free(pWdaParams->wdaMsgParam) ;
11120 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11121 vos_mem_free(pWdaParams) ;
11122
11123 //print a msg, nothing else to do
11124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11125 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11126
11127 return ;
11128}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11129/*
11130 * FUNCTION: WDA_GTKOffloadReqCallback
11131 * Free memory.
11132 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
11133 */
11134void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11135{
11136 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11137
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11139 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11140
11141 if(NULL == pWdaParams)
11142 {
11143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11144 "%s: pWdaParams received NULL", __func__);
11145 VOS_ASSERT(0);
11146 return;
11147 }
11148
11149 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11150 {
11151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11152 vos_mem_free(pWdaParams->wdaMsgParam);
11153 vos_mem_free(pWdaParams);
11154 }
11155
11156 return;
11157}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11158/*
11159 * FUNCTION: WDA_ProcessGTKOffloadReq
11160 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11161 * to broadcast traffic (sta mode).
11162 */
11163VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
11164 tpSirGtkOffloadParams pGtkOffloadParams)
11165{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11166 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11167 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
11168 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
11169 sizeof(WDI_GtkOffloadReqMsg)) ;
11170 tWDA_ReqParams *pWdaParams ;
11171
11172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11173 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11174
11175 if(NULL == wdiGtkOffloadReqMsg)
11176 {
11177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11178 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11179 VOS_ASSERT(0);
11180 return VOS_STATUS_E_NOMEM;
11181 }
11182
11183 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11184 if(NULL == pWdaParams)
11185 {
11186 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11187 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11188 VOS_ASSERT(0);
11189 vos_mem_free(wdiGtkOffloadReqMsg);
11190 return VOS_STATUS_E_NOMEM;
11191 }
11192
11193 //
11194 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
11195 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11196
11197 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11198 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11199
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11200 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
11201 // Copy KCK
11202 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
11203 // Copy KEK
11204 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
11205 // Copy KeyReplayCounter
11206 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
11207 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
11208
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11209 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
11210 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11211
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11212
11213 /* Store Params pass it to WDI */
11214 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
11215 pWdaParams->pWdaContext = pWDA;
11216 /* Store param pointer as passed in by caller */
11217 pWdaParams->wdaMsgParam = pGtkOffloadParams;
11218
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11219 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11220
11221 if(IS_WDI_STATUS_FAILURE(status))
11222 {
11223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11224 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
11225 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11226 vos_mem_free(pWdaParams->wdaMsgParam);
11227 vos_mem_free(pWdaParams);
11228 }
11229
11230 return CONVERT_WDI2VOS_STATUS(status) ;
11231}
11232
11233/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11234 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11235 *
11236 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11237void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11238 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11239{
11240 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11241 tWDA_CbContext *pWDA;
11242 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11243 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11244 vos_msg_t vosMsg;
11245
11246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11247 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11248
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11249 if(NULL == pWdaParams)
11250 {
11251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11252 "%s: pWdaParams received NULL", __func__);
11253 VOS_ASSERT(0);
11254 return;
11255 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11256
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11257 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
11258 if(NULL == pGtkOffloadGetInfoRsp)
11259 {
11260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11261 "%s: vos_mem_malloc failed ", __func__);
11262 VOS_ASSERT(0);
11263 return;
11264 }
11265
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11266 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
11267 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
11268
11269 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
11270 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
11271
11272 /* Message Header */
11273 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]11274 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11275
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11276 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
11277 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
11278 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
11279 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
11280 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11281
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11282 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11283 pwdiGtkOffloadGetInfoRsparams->bssId,
11284 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11285 /* VOS message wrapper */
11286 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11287 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11288 vosMsg.bodyval = 0;
11289
11290 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11291 {
11292 /* free the mem and return */
11293 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11294 }
11295
11296 vos_mem_free(pWdaParams->wdaMsgParam) ;
11297 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11298 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11299
11300 return;
11301}
11302/*
11303 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11304 * Free memory and send RSP back to SME.
11305 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11306 */
11307void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11308{
11309 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11310 vos_msg_t vosMsg;
11311
11312 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11313 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11314
11315 if(NULL == pWdaParams)
11316 {
11317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11318 "%s: pWdaParams received NULL", __func__);
11319 VOS_ASSERT(0);
11320 return;
11321 }
11322
11323 /* VOS message wrapper */
11324 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11325 vosMsg.bodyptr = NULL;
11326 vosMsg.bodyval = 0;
11327
11328 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11329 {
11330 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11331 vos_mem_free(pWdaParams->wdaMsgParam);
11332 vos_mem_free(pWdaParams);
11333 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11334 }
11335
11336 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11337}
11338#endif
11339
11340/*
11341 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11342 * Request to WDI to set Tx Per Tracking configurations
11343 */
11344VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11345{
11346 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11347 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11348 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11349 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11350 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11351 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11353 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11354 if(NULL == pwdiSetTxPerTrackingReqParams)
11355 {
11356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11357 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11358 vos_mem_free(pTxPerTrackingParams);
11359 VOS_ASSERT(0);
11360 return VOS_STATUS_E_NOMEM;
11361 }
11362 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11363 if(NULL == pWdaParams)
11364 {
11365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11366 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11367 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11368 vos_mem_free(pTxPerTrackingParams);
11369 VOS_ASSERT(0);
11370 return VOS_STATUS_E_NOMEM;
11371 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11372 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11373 pTxPerTrackingParams->ucTxPerTrackingEnable;
11374 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11375 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11376 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11377 pTxPerTrackingParams->ucTxPerTrackingRatio;
11378 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11379 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11380 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11381 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11382 /* Store param pointer as passed in by caller */
11383 /* store Params pass it to WDI
11384 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11385 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11386 pWdaParams->pWdaContext = pWDA;
11387 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11388 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11389 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11390 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11391 {
11392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11393 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11394 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11395 vos_mem_free(pWdaParams->wdaMsgParam) ;
11396 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11397 vos_mem_free(pWdaParams) ;
11398 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11399 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11400
11401}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11402/*
11403 * FUNCTION: WDA_HALDumpCmdCallback
11404 * Send the VOS complete .
11405 */
11406void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11407 void* pUserData)
11408{
11409 tANI_U8 *buffer = NULL;
11410 tWDA_CbContext *pWDA = NULL;
11411 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11412 if(NULL == pWdaParams)
11413 {
11414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11415 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11416 VOS_ASSERT(0) ;
11417 return ;
11418 }
11419
11420 pWDA = pWdaParams->pWdaContext;
11421 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11422 if(wdiRspParams->usBufferLen > 0)
11423 {
11424 /*Copy the Resp data to UMAC supplied buffer*/
11425 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11426 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11427 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11428 vos_mem_free(pWdaParams);
11429
11430 /* Indicate VOSS about the start complete */
11431 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11432 return ;
11433}
11434
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11435/*
11436 * FUNCTION: WDA_ProcessHALDumpCmdReq
11437 * Send Dump command to WDI
11438 */
11439VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11440 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11441 tANI_U32 arg4, tANI_U8 *pBuffer)
11442{
11443 WDI_Status status = WDI_STATUS_SUCCESS;
11444 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11445 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11446 tWDA_ReqParams *pWdaParams ;
11447 pVosContextType pVosContext = NULL;
11448 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11449 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11450 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11451 if(pVosContext)
11452 {
11453 if (pVosContext->isLogpInProgress)
11454 {
11455 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11456 "%s:LOGP in Progress. Ignore!!!", __func__);
11457 return VOS_STATUS_E_BUSY;
11458 }
11459 }
11460 else
11461 {
11462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11463 "%s: VOS Context Null", __func__);
11464 return VOS_STATUS_E_RESOURCES;
11465 }
11466
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11467 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11468 if(NULL == pWdaParams)
11469 {
11470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11471 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11472 return VOS_STATUS_E_NOMEM;
11473 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11474 /* Allocate memory WDI request structure*/
11475 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11476 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11477 if(NULL == wdiHALDumpCmdReqParam)
11478 {
11479 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11480 "WDA HAL DUMP Command buffer alloc fail");
11481 vos_mem_free(pWdaParams);
11482 return WDI_STATUS_E_FAILURE;
11483 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11484 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11485 /* Extract the arguments */
11486 wdiHalDumpCmdInfo->command = cmd;
11487 wdiHalDumpCmdInfo->argument1 = arg1;
11488 wdiHalDumpCmdInfo->argument2 = arg2;
11489 wdiHalDumpCmdInfo->argument3 = arg3;
11490 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11491 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11492 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11493
11494 /* Response message will be passed through the buffer */
11495 pWdaParams->wdaMsgParam = (void *)pBuffer;
11496
11497 /* store Params pass it to WDI */
11498 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11499 /* Send command to WDI */
11500 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11501 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11502 if ( vStatus != VOS_STATUS_SUCCESS )
11503 {
11504 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11505 {
11506 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11507 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11508 }
11509 else
11510 {
11511 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11512 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11513 }
11514 VOS_ASSERT(0);
11515 }
11516 return status;
11517}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11518#ifdef WLAN_FEATURE_GTK_OFFLOAD
11519/*
11520 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11521 * Request to WDI to get GTK Offload Information
11522 */
11523VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11524 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11525{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11526 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11527 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11528 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11529 tWDA_ReqParams *pWdaParams ;
11530
11531 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11532 {
11533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11534 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11535 VOS_ASSERT(0);
11536 return VOS_STATUS_E_NOMEM;
11537 }
11538
11539 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11540 if(NULL == pWdaParams)
11541 {
11542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11543 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11544 VOS_ASSERT(0);
11545 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11546 return VOS_STATUS_E_NOMEM;
11547 }
11548
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11549 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11550 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11551
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11552 /* Store Params pass it to WDI */
11553 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11554 pWdaParams->pWdaContext = pWDA;
11555 /* Store param pointer as passed in by caller */
11556 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11557
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11558 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11559 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11560
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11561 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11562
11563 if(IS_WDI_STATUS_FAILURE(status))
11564 {
11565 /* failure returned by WDI API */
11566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11567 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11568 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11569 vos_mem_free(pWdaParams) ;
11570 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11571 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11572 }
11573
11574 return CONVERT_WDI2VOS_STATUS(status) ;
11575}
11576#endif // WLAN_FEATURE_GTK_OFFLOAD
11577
11578/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11579 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11580 *
11581 */
11582VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11583 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11584{
11585 WDI_Status wdiStatus;
11586 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11587
11588 addPeriodicTxPtrnParams =
11589 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11590
11591 if (NULL == addPeriodicTxPtrnParams)
11592 {
11593 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11594 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11595 __func__);
11596
11597 return VOS_STATUS_E_NOMEM;
11598 }
11599
11600 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11601 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11602
11603 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11604 addPeriodicTxPtrnParams->pUserData = pWDA;
11605
11606 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11607
11608 if (WDI_STATUS_PENDING == wdiStatus)
11609 {
11610 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11611 "Pending received for %s:%d", __func__, __LINE__ );
11612 }
11613 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11614 {
11615 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11616 "Failure in %s:%d", __func__, __LINE__ );
11617 }
11618
11619 vos_mem_free(addPeriodicTxPtrnParams);
11620
11621 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11622}
11623
11624/*
11625 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11626 *
11627 */
11628VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11629 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11630{
11631 WDI_Status wdiStatus;
11632 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11633
11634 delPeriodicTxPtrnParams =
11635 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11636
11637 if (NULL == delPeriodicTxPtrnParams)
11638 {
11639 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11640 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11641 __func__);
11642
11643 return VOS_STATUS_E_NOMEM;
11644 }
11645
11646 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11647 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11648
11649 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11650 delPeriodicTxPtrnParams->pUserData = pWDA;
11651
11652 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11653
11654 if (WDI_STATUS_PENDING == wdiStatus)
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 != wdiStatus)
11660 {
11661 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11662 "Failure in %s:%d", __func__, __LINE__ );
11663 }
11664
11665 vos_mem_free(delPeriodicTxPtrnParams);
11666
11667 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11668}
11669
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11670#ifdef FEATURE_WLAN_BATCH_SCAN
11671/*
11672 * FUNCTION: WDA_ProcessStopBatchScanInd
11673 *
11674 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11675 *
11676 * PARAM:
11677 * pWDA: pointer to WDA context
11678 * pReq: pointer to stop batch scan request
11679 */
11680VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11681 tSirStopBatchScanInd *pReq)
11682{
11683 WDI_Status wdiStatus;
11684 WDI_StopBatchScanIndType wdiReq;
11685
11686 wdiReq.param = pReq->param;
11687
11688 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11689
11690 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11691 {
11692 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11693 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11694 }
11695
11696 vos_mem_free(pReq);
11697
11698 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11699}
11700/*==========================================================================
11701 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11702
11703 DESCRIPTION
11704 API to pull batch scan result from FW
11705
11706 PARAMETERS
11707 pWDA: Pointer to WDA context
11708 pGetBatchScanReq: Pointer to get batch scan result indication
11709
11710 RETURN VALUE
11711 NONE
11712
11713===========================================================================*/
11714VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11715 tSirTriggerBatchScanResultInd *pReq)
11716{
11717 WDI_Status wdiStatus;
11718 WDI_TriggerBatchScanResultIndType wdiReq;
11719
11720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11721 "------> %s " ,__func__);
11722
11723 wdiReq.param = pReq->param;
11724
11725 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11726
11727 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11728 {
11729 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11730 "Trigger batch scan result ind failed %s:%d",
11731 __func__, wdiStatus);
11732 }
11733
11734 vos_mem_free(pReq);
11735
11736 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11737}
11738
11739/*==========================================================================
11740 FUNCTION WDA_SetBatchScanRespCallback
11741
11742 DESCRIPTION
11743 API to process set batch scan response from FW
11744
11745 PARAMETERS
11746 pRsp: Pointer to set batch scan response
11747 pUserData: Pointer to user data
11748
11749 RETURN VALUE
11750 NONE
11751
11752===========================================================================*/
11753void WDA_SetBatchScanRespCallback
11754(
11755 WDI_SetBatchScanRspType *pRsp,
11756 void* pUserData
11757)
11758{
11759 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11760 tpAniSirGlobal pMac;
11761 void *pCallbackContext;
11762 tWDA_CbContext *pWDA = NULL ;
11763 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11764
11765
11766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11767 "<------ %s " ,__func__);
11768 if (NULL == pWdaParams)
11769 {
11770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11771 "%s: pWdaParams received NULL", __func__);
11772 VOS_ASSERT(0) ;
11773 return ;
11774 }
11775
11776 /*extract WDA context*/
11777 pWDA = pWdaParams->pWdaContext;
11778 if (NULL == pWDA)
11779 {
11780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11781 "%s:pWDA is NULL can't invole HDD callback",
11782 __func__);
11783 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11784 vos_mem_free(pWdaParams->wdaMsgParam);
11785 vos_mem_free(pWdaParams);
11786 VOS_ASSERT(0);
11787 return;
11788 }
11789
11790 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11791 vos_mem_free(pWdaParams->wdaMsgParam);
11792 vos_mem_free(pWdaParams);
11793
11794 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11795 if (NULL == pMac)
11796 {
11797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11798 "%s:pMac is NULL", __func__);
11799 VOS_ASSERT(0);
11800 return;
11801 }
11802
11803 pHddSetBatchScanRsp =
11804 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11805 if (NULL == pHddSetBatchScanRsp)
11806 {
11807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11808 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11809 VOS_ASSERT(0);
11810 return;
11811 }
11812
11813 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11814
11815 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11816 /*call hdd callback with set batch scan response data*/
11817 if(pMac->pmc.setBatchScanReqCallback)
11818 {
11819 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11820 }
11821 else
11822 {
11823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11824 "%s:HDD callback is null", __func__);
11825 VOS_ASSERT(0);
11826 }
11827
11828 vos_mem_free(pHddSetBatchScanRsp);
11829 return ;
11830}
11831
11832/*==========================================================================
11833 FUNCTION WDA_ProcessSetBatchScanReq
11834
11835 DESCRIPTION
11836 API to send set batch scan request to WDI
11837
11838 PARAMETERS
11839 pWDA: Pointer to WDA context
11840 pSetBatchScanReq: Pointer to set batch scan req
11841
11842 RETURN VALUE
11843 NONE
11844
11845===========================================================================*/
11846VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11847 tSirSetBatchScanReq *pSetBatchScanReq)
11848{
11849 WDI_Status status;
11850 tWDA_ReqParams *pWdaParams ;
11851 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11852
11853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11854 "------> %s " ,__func__);
11855
11856 pWdiSetBatchScanReq =
11857 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11858 if (NULL == pWdiSetBatchScanReq)
11859 {
11860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11861 "%s: VOS MEM Alloc Failure", __func__);
11862 vos_mem_free(pSetBatchScanReq);
11863 VOS_ASSERT(0);
11864 return VOS_STATUS_E_NOMEM;
11865 }
11866
11867 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11868 if (NULL == pWdaParams)
11869 {
11870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11871 "%s: VOS MEM Alloc Failure", __func__);
11872 VOS_ASSERT(0);
11873 vos_mem_free(pSetBatchScanReq);
11874 vos_mem_free(pWdiSetBatchScanReq);
11875 return VOS_STATUS_E_NOMEM;
11876 }
11877
11878 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11879 pWdiSetBatchScanReq->numberOfScansToBatch =
11880 pSetBatchScanReq->numberOfScansToBatch;
11881 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11882 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11883 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11884
11885 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11886 pWdaParams->pWdaContext = pWDA;
11887 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11888
11889 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11890 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11891 if (IS_WDI_STATUS_FAILURE(status))
11892 {
11893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11894 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11895 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11896 vos_mem_free(pWdaParams->wdaMsgParam);
11897 vos_mem_free(pWdaParams);
11898 }
11899 return CONVERT_WDI2VOS_STATUS(status);
11900}
11901
11902#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11903/*
11904 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11905 *
11906 * DESCRIPTION: This function sends start/update OBSS scan
11907 * inidcation message to WDI
11908 *
11909 * PARAM:
11910 * pWDA: pointer to WDA context
11911 * pReq: pointer to start OBSS scan request
11912 */
11913VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11914 tSirHT40OBSSScanInd *pReq)
11915{
11916 WDI_Status status;
11917 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11918 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11919
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11920 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11921 "------> %s " ,__func__);
11922 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11923 wdiOBSSScanParams.pUserData = pWDA;
11924
11925 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11926 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11927 pWdiOBSSScanInd->scanType = pReq->scanType;
11928 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11929 pReq->OBSSScanActiveDwellTime;
11930 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11931 pReq->OBSSScanPassiveDwellTime;
11932 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11933 pReq->BSSChannelWidthTriggerScanInterval;
11934 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11935 pReq->BSSWidthChannelTransitionDelayFactor;
11936 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11937 pReq->OBSSScanActiveTotalPerChannel;
11938 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11939 pReq->OBSSScanPassiveTotalPerChannel;
11940 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11941 pReq->OBSSScanActivityThreshold;
11942 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11943 vos_mem_copy(pWdiOBSSScanInd->channels,
11944 pReq->channels,
11945 pReq->channelCount);
11946 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11947 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11948 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11949 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11950 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11951
11952 vos_mem_copy(pWdiOBSSScanInd->ieField,
11953 pReq->ieField,
11954 pReq->ieFieldLen);
11955
11956 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11957 if (WDI_STATUS_PENDING == status)
11958 {
11959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11960 "Pending received for %s:%d ",__func__,__LINE__ );
11961 }
11962 else if (WDI_STATUS_SUCCESS_SYNC != status)
11963 {
11964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11965 "Failure in %s:%d ",__func__,__LINE__ );
11966 }
11967 return CONVERT_WDI2VOS_STATUS(status) ;
11968}
11969/*
11970 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11971 *
11972 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11973 *
11974 * PARAM:
11975 * pWDA: pointer to WDA context
11976 * pReq: pointer to stop batch scan request
11977 */
11978VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11979 tANI_U8 *bssIdx)
11980{
11981 WDI_Status status;
11982
11983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11984 "------> %s " ,__func__);
11985
11986 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11987 if (WDI_STATUS_PENDING == status)
11988 {
11989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11990 "Pending received for %s:%d ",__func__,__LINE__ );
11991 }
11992 else if (WDI_STATUS_SUCCESS_SYNC != status)
11993 {
11994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11995 "Failure in %s:%d ",__func__,__LINE__ );
11996 }
11997 return CONVERT_WDI2VOS_STATUS(status) ;
11998}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11999/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]12000 * FUNCTION: WDA_ProcessRateUpdateInd
12001 *
12002 */
12003VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
12004 tSirRateUpdateInd *pRateUpdateParams)
12005{
12006 WDI_Status wdiStatus;
12007 WDI_RateUpdateIndParams rateUpdateParams;
12008
12009 vos_mem_copy(rateUpdateParams.bssid,
12010 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
12011
12012 rateUpdateParams.ucastDataRateTxFlag =
12013 pRateUpdateParams->ucastDataRateTxFlag;
12014 rateUpdateParams.reliableMcastDataRateTxFlag =
12015 pRateUpdateParams->reliableMcastDataRateTxFlag;
12016 rateUpdateParams.mcastDataRate24GHzTxFlag =
12017 pRateUpdateParams->mcastDataRate24GHzTxFlag;
12018 rateUpdateParams.mcastDataRate5GHzTxFlag =
12019 pRateUpdateParams->mcastDataRate5GHzTxFlag;
12020
12021 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
12022 rateUpdateParams.reliableMcastDataRate =
12023 pRateUpdateParams->reliableMcastDataRate;
12024 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
12025 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
12026
12027 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
12028 rateUpdateParams.pUserData = pWDA;
12029
12030 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
12031
12032 if (WDI_STATUS_PENDING == wdiStatus)
12033 {
12034 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12035 "Pending received for %s:%d", __func__, __LINE__ );
12036 }
12037 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
12038 {
12039 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12040 "Failure in %s:%d", __func__, __LINE__ );
12041 }
12042
12043 vos_mem_free(pRateUpdateParams);
12044
12045 return CONVERT_WDI2VOS_STATUS(wdiStatus);
12046}
12047
12048/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12049 * -------------------------------------------------------------------------
12050 * DATA interface with WDI for Mgmt Frames
12051 * -------------------------------------------------------------------------
12052 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12053/*
12054 * FUNCTION: WDA_TxComplete
12055 * Callback function for the WDA_TxPacket
12056 */
12057VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
12058 VOS_STATUS status )
12059{
12060
12061 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12062 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12063 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12064
12065 if(NULL == wdaContext)
12066 {
12067 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12068 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12069 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12070 VOS_ASSERT(0);
12071 return VOS_STATUS_E_FAILURE;
12072 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12073
12074 /*Check if frame was timed out or not*/
12075 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
12076 (v_PVOID_t)&uUserData);
12077
12078 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
12079 {
12080 /*Discard frame - no further processing is needed*/
12081 vos_pkt_return_packet(pData);
12082 return VOS_STATUS_SUCCESS;
12083 }
12084
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12085 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
12086 if( NULL!=wdaContext->pTxCbFunc)
12087 {
12088 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12089 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]12090 {
12091 wdaContext->pTxCbFunc(pMac, pData);
12092 }
12093 else
12094 {
12095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12096 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12097 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12098 //Return from here since we reaching here because the packet already timeout
12099 return status;
12100 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12101 }
12102
12103 /*
12104 * Trigger the event to bring the HAL TL Tx complete function to come
12105 * out of wait
12106 * Let the coe above to complete the packet first. When this event is set,
12107 * the thread waiting for the event may run and set Vospacket_freed causing the original
12108 * packet not being freed.
12109 */
12110 status = vos_event_set(&wdaContext->txFrameEvent);
12111 if(!VOS_IS_STATUS_SUCCESS(status))
12112 {
12113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12114 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12115 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12116 return status;
12117}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12118/*
12119 * FUNCTION: WDA_TxPacket
12120 * Forward TX management frame to WDI
12121 */
12122VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
12123 void *pFrmBuf,
12124 tANI_U16 frmLen,
12125 eFrameType frmType,
12126 eFrameTxDir txDir,
12127 tANI_U8 tid,
12128 pWDATxRxCompFunc pCompFunc,
12129 void *pData,
12130 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]12131 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12132{
12133 VOS_STATUS status = VOS_STATUS_SUCCESS ;
12134 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
12135 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
12136 tANI_U8 eventIdx = 0;
12137 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
12138 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12139 if((NULL == pWDA)||(NULL == pFrmBuf))
12140 {
12141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12142 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12143 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12144 VOS_ASSERT(0);
12145 return VOS_STATUS_E_FAILURE;
12146 }
12147
12148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12149 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12150 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
12151 if(NULL == pMac)
12152 {
12153 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12154 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12155 VOS_ASSERT(0);
12156 return VOS_STATUS_E_FAILURE;
12157 }
12158
12159
12160
12161 /* store the call back function in WDA context */
12162 pWDA->pTxCbFunc = pCompFunc;
12163 /* store the call back for the function of ackTxComplete */
12164 if( pAckTxComp )
12165 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12166 if( NULL != pWDA->pAckTxCbFunc )
12167 {
12168 /* Already TxComp is active no need to active again */
12169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12170 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12171 pWDA->pAckTxCbFunc( pMac, 0);
12172 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12173
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12174 if( VOS_STATUS_SUCCESS !=
12175 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12176 {
12177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12178 "Tx Complete timeout Timer Stop Failed ");
12179 }
12180 else
12181 {
12182 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12183 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12184 }
12185 }
12186
12187 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
12188 pWDA->pAckTxCbFunc = pAckTxComp;
12189 if( VOS_STATUS_SUCCESS !=
12190 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
12191 {
12192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12193 "Tx Complete Timer Start Failed ");
12194 pWDA->pAckTxCbFunc = NULL;
12195 return eHAL_STATUS_FAILURE;
12196 }
12197 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12198 /* Reset the event to be not signalled */
12199 status = vos_event_reset(&pWDA->txFrameEvent);
12200 if(!VOS_IS_STATUS_SUCCESS(status))
12201 {
12202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12203 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12204 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
12205 if( pAckTxComp )
12206 {
12207 pWDA->pAckTxCbFunc = NULL;
12208 if( VOS_STATUS_SUCCESS !=
12209 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12210 {
12211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12212 "Tx Complete timeout Timer Stop Failed ");
12213 }
12214 }
12215 return VOS_STATUS_E_FAILURE;
12216 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12217
12218 /* If Peer Sta mask is set don't overwrite to self sta */
12219 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12220 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12221 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12222 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12223 else
12224 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12225 /* Get system role, use the self station if in unknown role or STA role */
12226 systemRole = wdaGetGlobalSystemRole(pMac);
12227 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
12228 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12229#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12230 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12231#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12232 ))
12233 {
12234 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
12235 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]12236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12237
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12238 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
12239 disassoc frame reaches the HW, HAL has already deleted the peer station */
12240 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12241 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]12242 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12243 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12244 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12245 /*Send Probe request frames on self sta idx*/
12246 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12247 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12248 /* Since we donot want probe responses to be retried, send probe responses
12249 through the NO_ACK queues */
12250 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
12251 {
12252 //probe response is sent out using self station and no retries options.
12253 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
12254 }
12255 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
12256 {
12257 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
12258 }
12259 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12260 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]12261
12262 /*Set frame tag to 0
12263 We will use the WDA user data in order to tag a frame as expired*/
12264 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12265 (v_PVOID_t)0);
12266
12267
12268 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
12269 frmLen, ucTypeSubType, tid,
12270 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
12271 {
12272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12273 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12274 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12275 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]12276 if( pAckTxComp )
12277 {
12278 pWDA->pAckTxCbFunc = NULL;
12279 if( VOS_STATUS_SUCCESS !=
12280 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12281 {
12282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12283 "Tx Complete timeout Timer Stop Failed ");
12284 }
12285 }
12286 return VOS_STATUS_E_FAILURE;
12287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12288 /*
12289 * Wait for the event to be set by the TL, to get the response of TX
12290 * complete, this event should be set by the Callback function called by TL
12291 */
12292 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12293 &eventIdx);
12294 if(!VOS_IS_STATUS_SUCCESS(status))
12295 {
12296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12297 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12298 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12299 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12300 after the packet gets completed(packet freed once)*/
12301
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12302 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame]12303 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12304
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12305 /*Tag Frame as timed out for later deletion*/
12306 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12307 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12308
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12309 /* check whether the packet was freed already,so need not free again when
12310 * TL calls the WDA_Txcomplete routine
12311 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12312 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12313 /*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]12314 {
12315 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12316 } */
12317
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12318 if( pAckTxComp )
12319 {
12320 pWDA->pAckTxCbFunc = NULL;
12321 if( VOS_STATUS_SUCCESS !=
12322 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12323 {
12324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12325 "Tx Complete timeout Timer Stop Failed ");
12326 }
12327 }
12328 status = VOS_STATUS_E_FAILURE;
12329 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12330#ifdef WLAN_DUMP_MGMTFRAMES
12331 if (VOS_IS_STATUS_SUCCESS(status))
12332 {
12333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12334 "%s() TX packet : SubType %d", __func__,pFc->subType);
12335 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12336 pData, frmLen);
12337 }
12338#endif
12339
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12340 if (VOS_IS_STATUS_SUCCESS(status))
12341 {
12342 if (pMac->fEnableDebugLog & 0x1)
12343 {
12344 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12345 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12346 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12347 {
12348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12349 pFc->type, pFc->subType);
12350 }
12351 }
12352 }
12353
12354
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12355 return status;
12356}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12357/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12358 * FUNCTION: WDA_ProcessDHCPStartInd
12359 * Forward DHCP Start to WDI
12360 */
12361static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12362 tAniDHCPInd *dhcpStartInd)
12363{
12364 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12365 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12366
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12367 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12368 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12369 sizeof(tSirMacAddr));
12370
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12371 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12372
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12373 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12374 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12376 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12377 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12378 else if (WDI_STATUS_SUCCESS_SYNC != status)
12379 {
12380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12381 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12382 }
12383
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12384 vos_mem_free(dhcpStartInd);
12385 return CONVERT_WDI2VOS_STATUS(status) ;
12386}
12387
12388 /*
12389 * FUNCTION: WDA_ProcessDHCPStopInd
12390 * Forward DHCP Stop to WDI
12391 */
12392 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12393 tAniDHCPInd *dhcpStopInd)
12394 {
12395 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12396 WDI_DHCPInd wdiDHCPInd;
12397
12398 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12399 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12400
12401 status = WDI_dhcpStopInd(&wdiDHCPInd);
12402
12403 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12404 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12405 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12406 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12407 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12408 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12409 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12411 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12412 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12413
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12414 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12415
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12416 return CONVERT_WDI2VOS_STATUS(status) ;
12417 }
12418
12419/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]12420 * FUNCTION: WDA_ProcessSetSpoofMacAddrReq
12421 *
12422 * DESCRIPTION: This function sends Spoof Mac Addr Req to WDI
12423 *
12424 * PARAM:
12425 * pWDA: pointer to WDA context
12426 * pReq: pointer to stop batch scan request
12427 */
12428VOS_STATUS WDA_ProcessSetSpoofMacAddrReq(tWDA_CbContext *pWDA,
12429 tpSpoofMacAddrReqParams pReq)
12430{
12431 WDI_Status wdiStatus;
12432 WDI_SpoofMacAddrInfoType *WDI_SpoofMacAddrInfoParams;
12433 tWDA_ReqParams *pWdaParams;
12434
12435 WDI_SpoofMacAddrInfoParams = (WDI_SpoofMacAddrInfoType *)vos_mem_malloc(
12436 sizeof(WDI_SpoofMacAddrInfoType));
12437 if(NULL == WDI_SpoofMacAddrInfoParams) {
12438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12439 "%s: VOS MEM Alloc Failure in Spoof Req", __func__);
12440 VOS_ASSERT(0);
12441 return VOS_STATUS_E_NOMEM;
12442 }
12443 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12444 if(NULL == pWdaParams) {
12445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12446 "%s: VOS MEM Alloc Failure", __func__);
12447 VOS_ASSERT(0);
12448 return VOS_STATUS_E_NOMEM;
12449 }
12450
12451 vos_mem_copy(WDI_SpoofMacAddrInfoParams->macAddr,
12452 pReq->macAddr, VOS_MAC_ADDRESS_LEN);
12453
12454 pWdaParams->pWdaContext = pWDA;
12455 /* Store Upper layer req pointer, as this will be used for response */
12456 pWdaParams->wdaMsgParam = (void *)pReq ;
12457 /* store Params pass it to WDI */
12458 pWdaParams->wdaWdiApiMsgParam = (void *)WDI_SpoofMacAddrInfoParams ;
12459
12460 wdiStatus = WDI_SetSpoofMacAddrReq(WDI_SpoofMacAddrInfoParams,
12461 (WDI_SetSpoofMacAddrRspCb) WDA_SpoofMacAddrRspCallback,
12462 pWdaParams );
12463
12464 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12465 {
12466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12467 "Failure in SetSpoofMacAddrReq Params WDI API, free all the memory " );
12468 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12469 vos_mem_free(pWdaParams->wdaMsgParam);
12470 vos_mem_free(pWdaParams);
12471 }
12472
12473 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
12474}
12475
12476/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12477 * FUNCTION: WDA_McProcessMsg
12478 * Trigger DAL-AL to start CFG download
12479 */
12480VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12481{
12482 VOS_STATUS status = VOS_STATUS_SUCCESS;
12483 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12484 if(NULL == pMsg)
12485 {
12486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12487 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12488 VOS_ASSERT(0);
12489 return VOS_STATUS_E_FAILURE;
12490 }
12491
12492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12493 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12494
12495 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12496 if(NULL == pWDA )
12497 {
12498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12499 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12500 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12501 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12502 return VOS_STATUS_E_FAILURE;
12503 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12504 /* Process all the WDA messages.. */
12505 switch( pMsg->type )
12506 {
12507 case WNI_CFG_DNLD_REQ:
12508 {
12509 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12510 /* call WDA complete event if config download success */
12511 if( VOS_IS_STATUS_SUCCESS(status) )
12512 {
12513 vos_WDAComplete_cback(pVosContext);
12514 }
12515 else
12516 {
12517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12518 "WDA Config Download failure" );
12519 }
12520 break ;
12521 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12522 /*
12523 * Init SCAN request from PE, convert it into DAL format
12524 * and send it to DAL
12525 */
12526 case WDA_INIT_SCAN_REQ:
12527 {
12528 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12529 break ;
12530 }
12531 /* start SCAN request from PE */
12532 case WDA_START_SCAN_REQ:
12533 {
12534 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12535 break ;
12536 }
12537 /* end SCAN request from PE */
12538 case WDA_END_SCAN_REQ:
12539 {
12540 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12541 break ;
12542 }
12543 /* end SCAN request from PE */
12544 case WDA_FINISH_SCAN_REQ:
12545 {
12546 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12547 break ;
12548 }
12549 /* join request from PE */
12550 case WDA_CHNL_SWITCH_REQ:
12551 {
12552 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12553 {
12554 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12555 }
12556 else
12557 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12558 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12559 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12560 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12561 {
12562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12563 "call ProcessChannelSwitchReq_V1" );
12564 WDA_ProcessChannelSwitchReq_V1(pWDA,
12565 (tSwitchChannelParams*)pMsg->bodyptr) ;
12566 }
12567 else
12568 {
12569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12570 "call ProcessChannelSwitchReq" );
12571 WDA_ProcessChannelSwitchReq(pWDA,
12572 (tSwitchChannelParams*)pMsg->bodyptr) ;
12573 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12574 }
12575 break ;
12576 }
12577 /* ADD BSS request from PE */
12578 case WDA_ADD_BSS_REQ:
12579 {
12580 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12581 break ;
12582 }
12583 case WDA_ADD_STA_REQ:
12584 {
12585 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12586 break ;
12587 }
12588 case WDA_DELETE_BSS_REQ:
12589 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12590 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12591 break ;
12592 }
12593 case WDA_DELETE_STA_REQ:
12594 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12595 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12596 break ;
12597 }
12598 case WDA_CONFIG_PARAM_UPDATE_REQ:
12599 {
12600 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12601 break ;
12602 }
12603 case WDA_SET_BSSKEY_REQ:
12604 {
12605 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12606 break ;
12607 }
12608 case WDA_SET_STAKEY_REQ:
12609 {
12610 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12611 break ;
12612 }
12613 case WDA_SET_STA_BCASTKEY_REQ:
12614 {
12615 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12616 break ;
12617 }
12618 case WDA_REMOVE_BSSKEY_REQ:
12619 {
12620 WDA_ProcessRemoveBssKeyReq(pWDA,
12621 (tRemoveBssKeyParams *)pMsg->bodyptr);
12622 break ;
12623 }
12624 case WDA_REMOVE_STAKEY_REQ:
12625 {
12626 WDA_ProcessRemoveStaKeyReq(pWDA,
12627 (tRemoveStaKeyParams *)pMsg->bodyptr);
12628 break ;
12629 }
12630 case WDA_REMOVE_STA_BCASTKEY_REQ:
12631 {
12632 /* TODO: currently UMAC is not sending this request, Add the code for
12633 handling this request when UMAC supports */
12634 break;
12635 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12636#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12637 case WDA_TSM_STATS_REQ:
12638 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12639 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12640 break;
12641 }
12642#endif
12643 case WDA_UPDATE_EDCA_PROFILE_IND:
12644 {
12645 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12646 break;
12647 }
12648 case WDA_ADD_TS_REQ:
12649 {
12650 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12651 break;
12652 }
12653 case WDA_DEL_TS_REQ:
12654 {
12655 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12656 break;
12657 }
12658 case WDA_ADDBA_REQ:
12659 {
12660 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12661 break;
12662 }
12663 case WDA_DELBA_IND:
12664 {
12665 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12666 break;
12667 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12668 case WDA_UPDATE_CHAN_LIST_REQ:
12669 {
12670 WDA_ProcessUpdateChannelList(pWDA,
12671 (tSirUpdateChanList *)pMsg->bodyptr);
12672 break;
12673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12674 case WDA_SET_LINK_STATE:
12675 {
12676 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12677 break;
12678 }
12679 case WDA_GET_STATISTICS_REQ:
12680 {
12681 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12682 break;
12683 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12684#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12685 case WDA_GET_ROAM_RSSI_REQ:
12686 {
12687 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12688 break;
12689 }
12690#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12691 case WDA_PWR_SAVE_CFG:
12692 {
12693 if(pWDA->wdaState == WDA_READY_STATE)
12694 {
12695 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12696 }
12697 else
12698 {
12699 if(NULL != pMsg->bodyptr)
12700 {
12701 vos_mem_free(pMsg->bodyptr);
12702 }
12703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12704 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12705 }
12706 break;
12707 }
12708 case WDA_ENTER_IMPS_REQ:
12709 {
12710 if(pWDA->wdaState == WDA_READY_STATE)
12711 {
12712 WDA_ProcessEnterImpsReq(pWDA);
12713 }
12714 else
12715 {
12716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12717 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12718 }
12719 break;
12720 }
12721 case WDA_EXIT_IMPS_REQ:
12722 {
12723 if(pWDA->wdaState == WDA_READY_STATE)
12724 {
12725 WDA_ProcessExitImpsReq(pWDA);
12726 }
12727 else
12728 {
12729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12730 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12731 }
12732 break;
12733 }
12734 case WDA_ENTER_BMPS_REQ:
12735 {
12736 if(pWDA->wdaState == WDA_READY_STATE)
12737 {
12738 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12739 }
12740 else
12741 {
12742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12743 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12744 }
12745 break;
12746 }
12747 case WDA_EXIT_BMPS_REQ:
12748 {
12749 if(pWDA->wdaState == WDA_READY_STATE)
12750 {
12751 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12752 }
12753 else
12754 {
12755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12756 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12757 }
12758 break;
12759 }
12760 case WDA_ENTER_UAPSD_REQ:
12761 {
12762 if(pWDA->wdaState == WDA_READY_STATE)
12763 {
12764 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12765 }
12766 else
12767 {
12768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12769 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12770 }
12771 break;
12772 }
12773 case WDA_EXIT_UAPSD_REQ:
12774 {
12775 if(pWDA->wdaState == WDA_READY_STATE)
12776 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12777 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12778 }
12779 else
12780 {
12781 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12782 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12783 }
12784 break;
12785 }
12786 case WDA_UPDATE_UAPSD_IND:
12787 {
12788 if(pWDA->wdaState == WDA_READY_STATE)
12789 {
12790 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12791 }
12792 else
12793 {
12794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12795 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12796 }
12797 break;
12798 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12799 case WDA_REGISTER_PE_CALLBACK :
12800 {
12801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12802 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12803 /*TODO: store the PE callback */
12804 /* Do Nothing? MSG Body should be freed at here */
12805 if(NULL != pMsg->bodyptr)
12806 {
12807 vos_mem_free(pMsg->bodyptr);
12808 }
12809 break;
12810 }
12811 case WDA_SYS_READY_IND :
12812 {
12813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12814 "Handling msg type WDA_SYS_READY_IND " );
12815 pWDA->wdaState = WDA_READY_STATE;
12816 if(NULL != pMsg->bodyptr)
12817 {
12818 vos_mem_free(pMsg->bodyptr);
12819 }
12820 break;
12821 }
12822 case WDA_BEACON_FILTER_IND :
12823 {
12824 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12825 break;
12826 }
12827 case WDA_BTC_SET_CFG:
12828 {
12829 /*TODO: handle this while dealing with BTC */
12830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12831 "Handling msg type WDA_BTC_SET_CFG " );
12832 /* Do Nothing? MSG Body should be freed at here */
12833 if(NULL != pMsg->bodyptr)
12834 {
12835 vos_mem_free(pMsg->bodyptr);
12836 }
12837 break;
12838 }
12839 case WDA_SIGNAL_BT_EVENT:
12840 {
12841 /*TODO: handle this while dealing with BTC */
12842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12843 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12844 /* Do Nothing? MSG Body should be freed at here */
12845 if(NULL != pMsg->bodyptr)
12846 {
12847 vos_mem_free(pMsg->bodyptr);
12848 }
12849 break;
12850 }
12851 case WDA_CFG_RXP_FILTER_REQ:
12852 {
12853 WDA_ProcessConfigureRxpFilterReq(pWDA,
12854 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12855 break;
12856 }
12857 case WDA_SET_HOST_OFFLOAD:
12858 {
12859 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12860 break;
12861 }
12862 case WDA_SET_KEEP_ALIVE:
12863 {
12864 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12865 break;
12866 }
12867#ifdef WLAN_NS_OFFLOAD
12868 case WDA_SET_NS_OFFLOAD:
12869 {
12870 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12871 break;
12872 }
12873#endif //WLAN_NS_OFFLOAD
12874 case WDA_ADD_STA_SELF_REQ:
12875 {
12876 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12877 break;
12878 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12879 case WDA_DEL_STA_SELF_REQ:
12880 {
12881 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12882 break;
12883 }
12884 case WDA_WOWL_ADD_BCAST_PTRN:
12885 {
12886 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12887 break;
12888 }
12889 case WDA_WOWL_DEL_BCAST_PTRN:
12890 {
12891 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12892 break;
12893 }
12894 case WDA_WOWL_ENTER_REQ:
12895 {
12896 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12897 break;
12898 }
12899 case WDA_WOWL_EXIT_REQ:
12900 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12901 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12902 break;
12903 }
12904 case WDA_TL_FLUSH_AC_REQ:
12905 {
12906 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12907 break;
12908 }
12909 case WDA_SIGNAL_BTAMP_EVENT:
12910 {
12911 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12912 break;
12913 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12914#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12915 case WDA_LINK_LAYER_STATS_SET_REQ:
12916 {
12917 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12918 break;
12919 }
12920 case WDA_LINK_LAYER_STATS_GET_REQ:
12921 {
12922 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12923 break;
12924 }
12925 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12926 {
12927 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12928 break;
12929 }
12930#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12931#ifdef WLAN_FEATURE_EXTSCAN
12932 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12933 {
12934 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12935 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12936 break;
12937 }
12938 case WDA_EXTSCAN_START_REQ:
12939 {
12940 WDA_ProcessEXTScanStartReq(pWDA,
12941 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12942 break;
12943 }
12944 case WDA_EXTSCAN_STOP_REQ:
12945 {
12946 WDA_ProcessEXTScanStopReq(pWDA,
12947 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12948 break;
12949 }
12950 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12951 {
12952 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12953 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12954 break;
12955 }
12956 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12957 {
12958 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12959 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12960 break;
12961 }
12962 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12963 {
12964 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12965 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12966 break;
12967 }
12968 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12969 {
12970 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12971 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12972 break;
12973 }
12974 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12975 {
12976 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12977 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12978 break;
12979 }
12980#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12981#ifdef WDA_UT
12982 case WDA_WDI_EVENT_MSG:
12983 {
12984 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12985 break ;
12986 }
12987#endif
12988 case WDA_UPDATE_BEACON_IND:
12989 {
12990 WDA_ProcessUpdateBeaconParams(pWDA,
12991 (tUpdateBeaconParams *)pMsg->bodyptr);
12992 break;
12993 }
12994 case WDA_SEND_BEACON_REQ:
12995 {
12996 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12997 break;
12998 }
12999 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
13000 {
13001 WDA_ProcessUpdateProbeRspTemplate(pWDA,
13002 (tSendProbeRespParams *)pMsg->bodyptr);
13003 break;
13004 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]13005#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13006 case WDA_SET_MAX_TX_POWER_REQ:
13007 {
13008 WDA_ProcessSetMaxTxPowerReq(pWDA,
13009 (tMaxTxPowerParams *)pMsg->bodyptr);
13010 break;
13011 }
13012#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]13013 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
13014 {
13015 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
13016 pMsg->bodyptr);
13017 break;
13018 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]13019 case WDA_SET_TX_POWER_REQ:
13020 {
13021 WDA_ProcessSetTxPowerReq(pWDA,
13022 (tSirSetTxPowerReq *)pMsg->bodyptr);
13023 break;
13024 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13025 case WDA_SET_P2P_GO_NOA_REQ:
13026 {
13027 WDA_ProcessSetP2PGONOAReq(pWDA,
13028 (tP2pPsParams *)pMsg->bodyptr);
13029 break;
13030 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13031 /* timer related messages */
13032 case WDA_TIMER_BA_ACTIVITY_REQ:
13033 {
13034 WDA_BaCheckActivity(pWDA) ;
13035 break ;
13036 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13037
13038 /* timer related messages */
13039 case WDA_TIMER_TRAFFIC_STATS_IND:
13040 {
13041 WDA_TimerTrafficStatsInd(pWDA);
13042 break;
13043 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13044#ifdef WLAN_FEATURE_VOWIFI_11R
13045 case WDA_AGGR_QOS_REQ:
13046 {
13047 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
13048 break;
13049 }
13050#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13051 case WDA_FTM_CMD_REQ:
13052 {
13053 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
13054 break ;
13055 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13056#ifdef FEATURE_OEM_DATA_SUPPORT
13057 case WDA_START_OEM_DATA_REQ:
13058 {
13059 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
13060 break;
13061 }
13062#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13063 /* Tx Complete Time out Indication */
13064 case WDA_TX_COMPLETE_TIMEOUT_IND:
13065 {
13066 WDA_ProcessTxCompleteTimeOutInd(pWDA);
13067 break;
13068 }
13069 case WDA_WLAN_SUSPEND_IND:
13070 {
13071 WDA_ProcessWlanSuspendInd(pWDA,
13072 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
13073 break;
13074 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13075 case WDA_WLAN_RESUME_REQ:
13076 {
13077 WDA_ProcessWlanResumeReq(pWDA,
13078 (tSirWlanResumeParam *)pMsg->bodyptr) ;
13079 break;
13080 }
13081
13082 case WDA_UPDATE_CF_IND:
13083 {
13084 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
13085 pMsg->bodyptr = NULL;
13086 break;
13087 }
13088#ifdef FEATURE_WLAN_SCAN_PNO
13089 case WDA_SET_PNO_REQ:
13090 {
13091 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
13092 break;
13093 }
13094 case WDA_UPDATE_SCAN_PARAMS_REQ:
13095 {
13096 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
13097 break;
13098 }
13099 case WDA_SET_RSSI_FILTER_REQ:
13100 {
13101 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
13102 break;
13103 }
13104#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13105#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13106 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13107 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13108 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13109 break;
13110 }
13111#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13112 case WDA_SET_TX_PER_TRACKING_REQ:
13113 {
13114 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
13115 break;
13116 }
13117
13118#ifdef WLAN_FEATURE_PACKET_FILTERING
13119 case WDA_8023_MULTICAST_LIST_REQ:
13120 {
13121 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
13122 break;
13123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13124 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
13125 {
13126 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
13127 break;
13128 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13129 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
13130 {
13131 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
13132 break;
13133 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13134 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
13135 {
13136 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
13137 break;
13138 }
13139#endif // WLAN_FEATURE_PACKET_FILTERING
13140
13141
13142 case WDA_TRANSMISSION_CONTROL_IND:
13143 {
13144 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
13145 break;
13146 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13147 case WDA_SET_POWER_PARAMS_REQ:
13148 {
13149 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
13150 break;
13151 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13152#ifdef WLAN_FEATURE_GTK_OFFLOAD
13153 case WDA_GTK_OFFLOAD_REQ:
13154 {
13155 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
13156 break;
13157 }
13158
13159 case WDA_GTK_OFFLOAD_GETINFO_REQ:
13160 {
13161 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
13162 break;
13163 }
13164#endif //WLAN_FEATURE_GTK_OFFLOAD
13165
13166 case WDA_SET_TM_LEVEL_REQ:
13167 {
13168 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
13169 break;
13170 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13171
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13172 case WDA_UPDATE_OP_MODE:
13173 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13174 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
13175 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
13176 {
13177 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13178 }
13179 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13180 {
13181 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
13182 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13183 else
13184 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13185 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13186 }
13187 else
13188 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13189 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13190 break;
13191 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]13192#ifdef WLAN_FEATURE_11W
13193 case WDA_EXCLUDE_UNENCRYPTED_IND:
13194 {
13195 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
13196 break;
13197 }
13198#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13199#ifdef FEATURE_WLAN_TDLS
13200 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
13201 {
13202 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
13203 break;
13204 }
13205#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13206 case WDA_DHCP_START_IND:
13207 {
13208 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13209 break;
13210 }
13211 case WDA_DHCP_STOP_IND:
13212 {
13213 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13214 break;
13215 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13216#ifdef FEATURE_WLAN_LPHB
13217 case WDA_LPHB_CONF_REQ:
13218 {
13219 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
13220 break;
13221 }
13222#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13223 case WDA_ADD_PERIODIC_TX_PTRN_IND:
13224 {
13225 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
13226 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
13227 break;
13228 }
13229 case WDA_DEL_PERIODIC_TX_PTRN_IND:
13230 {
13231 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
13232 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
13233 break;
13234 }
13235
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13236#ifdef FEATURE_WLAN_BATCH_SCAN
13237 case WDA_SET_BATCH_SCAN_REQ:
13238 {
13239 WDA_ProcessSetBatchScanReq(pWDA,
13240 (tSirSetBatchScanReq *)pMsg->bodyptr);
13241 break;
13242 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13243 case WDA_RATE_UPDATE_IND:
13244 {
13245 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
13246 break;
13247 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13248 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
13249 {
13250 WDA_ProcessTriggerBatchScanResultInd(pWDA,
13251 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
13252 break;
13253 }
13254 case WDA_STOP_BATCH_SCAN_IND:
13255 {
13256 WDA_ProcessStopBatchScanInd(pWDA,
13257 (tSirStopBatchScanInd *)pMsg->bodyptr);
13258 break;
13259 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]13260 case WDA_GET_BCN_MISS_RATE_REQ:
13261 WDA_ProcessGetBcnMissRateReq(pWDA,
13262 (tSirBcnMissRateReq *)pMsg->bodyptr);
13263 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13264#endif
13265
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13266 case WDA_HT40_OBSS_SCAN_IND:
13267 {
13268 WDA_ProcessHT40OBSSScanInd(pWDA,
13269 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
13270 break;
13271 }
13272 case WDA_HT40_OBSS_STOP_SCAN_IND:
13273 {
13274 WDA_ProcessHT40OBSSStopScanInd(pWDA,
13275 (tANI_U8*)pMsg->bodyptr);
13276 break;
13277 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]13278// tdlsoffchan
13279#ifdef FEATURE_WLAN_TDLS
13280 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
13281 {
13282 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
13283 break;
13284 }
13285#endif
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13286 case WDA_SPOOF_MAC_ADDR_REQ:
13287 {
13288 WDA_ProcessSetSpoofMacAddrReq(pWDA, (tpSpoofMacAddrReqParams)pMsg->bodyptr);
13289 break;
13290 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13291 default:
13292 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]13293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13294 "No Handling for msg type %x in WDA "
13295 ,pMsg->type);
13296 /* Do Nothing? MSG Body should be freed at here */
13297 if(NULL != pMsg->bodyptr)
13298 {
13299 vos_mem_free(pMsg->bodyptr);
13300 }
13301 //WDA_VOS_ASSERT(0) ;
13302 }
13303 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13304 return status ;
13305}
13306
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13307/*
13308 * FUNCTION: WDA_LowLevelIndCallback
13309 * IND API callback from WDI, send Ind to PE
13310 */
13311void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
13312 void* pUserData )
13313{
13314 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
13315#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13316 tSirRSSINotification rssiNotification;
13317#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13318 if(NULL == pWDA)
13319 {
13320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13321 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13322 VOS_ASSERT(0);
13323 return ;
13324 }
13325
13326 switch(wdiLowLevelInd->wdiIndicationType)
13327 {
13328 case WDI_RSSI_NOTIFICATION_IND:
13329 {
13330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13331 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13332#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13333 rssiNotification.bReserved =
13334 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
13335 rssiNotification.bRssiThres1NegCross =
13336 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
13337 rssiNotification.bRssiThres1PosCross =
13338 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
13339 rssiNotification.bRssiThres2NegCross =
13340 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
13341 rssiNotification.bRssiThres2PosCross =
13342 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
13343 rssiNotification.bRssiThres3NegCross =
13344 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
13345 rssiNotification.bRssiThres3PosCross =
13346 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]13347 rssiNotification.avgRssi = (v_S7_t)
13348 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13349 WLANTL_BMPSRSSIRegionChangedNotification(
13350 pWDA->pVosContext,
13351 &rssiNotification);
13352#endif
13353 break ;
13354 }
13355 case WDI_MISSED_BEACON_IND:
13356 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13357 tpSirSmeMissedBeaconInd pMissBeacInd =
13358 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13360 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13361 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13362 if(NULL == pMissBeacInd)
13363 {
13364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13365 "%s: VOS MEM Alloc Failure", __func__);
13366 break;
13367 }
13368 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13369 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13370 pMissBeacInd->bssIdx =
13371 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13372 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13373 break ;
13374 }
13375 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13376 {
13377 /* TODO: Decode Ind and send Ind to PE */
13378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13379 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13380 break ;
13381 }
13382
13383 case WDI_MIC_FAILURE_IND:
13384 {
13385 tpSirSmeMicFailureInd pMicInd =
13386 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13387
13388 if(NULL == pMicInd)
13389 {
13390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13391 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13392 break;
13393 }
13394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13395 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13396 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13397 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13398 vos_mem_copy(pMicInd->bssId,
13399 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13400 sizeof(tSirMacAddr));
13401 vos_mem_copy(pMicInd->info.srcMacAddr,
13402 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13403 sizeof(tSirMacAddr));
13404 vos_mem_copy(pMicInd->info.taMacAddr,
13405 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13406 sizeof(tSirMacAddr));
13407 vos_mem_copy(pMicInd->info.dstMacAddr,
13408 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13409 sizeof(tSirMacAddr));
13410 vos_mem_copy(pMicInd->info.rxMacAddr,
13411 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13412 sizeof(tSirMacAddr));
13413 pMicInd->info.multicast =
13414 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13415 pMicInd->info.keyId=
13416 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13417 pMicInd->info.IV1=
13418 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13419 vos_mem_copy(pMicInd->info.TSC,
13420 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13421 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13422 (void *)pMicInd , 0) ;
13423 break ;
13424 }
13425 case WDI_FATAL_ERROR_IND:
13426 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13427 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13428 /* TODO: Decode Ind and send Ind to PE */
13429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13430 "Received WDI_FATAL_ERROR_IND from WDI ");
13431 break ;
13432 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13433 case WDI_DEL_STA_IND:
13434 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13435 tpDeleteStaContext pDelSTACtx =
13436 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13437
13438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13439 "Received WDI_DEL_STA_IND from WDI ");
13440 if(NULL == pDelSTACtx)
13441 {
13442 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13443 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13444 break;
13445 }
13446 vos_mem_copy(pDelSTACtx->addr2,
13447 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13448 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13449 vos_mem_copy(pDelSTACtx->bssId,
13450 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13451 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13452 pDelSTACtx->assocId =
13453 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13454 pDelSTACtx->reasonCode =
13455 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13456 pDelSTACtx->staId =
13457 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13458 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13459 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13460 break ;
13461 }
13462 case WDI_COEX_IND:
13463 {
13464 tANI_U32 index;
13465 vos_msg_t vosMsg;
13466 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13467 if(NULL == pSmeCoexInd)
13468 {
13469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13470 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13471 break;
13472 }
13473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13474 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13475 /* Message Header */
13476 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13477 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13478 /* Info from WDI Indication */
13479 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13480 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13481 {
13482 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13483 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13484 /* VOS message wrapper */
13485 vosMsg.type = eWNI_SME_COEX_IND;
13486 vosMsg.bodyptr = (void *)pSmeCoexInd;
13487 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13488 /* Send message to SME */
13489 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13490 {
13491 /* free the mem and return */
13492 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13493 }
13494 else
13495 {
13496 /* DEBUG */
13497 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13498 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13499 pSmeCoexInd->coexIndType,
13500 pSmeCoexInd->coexIndData[0],
13501 pSmeCoexInd->coexIndData[1],
13502 pSmeCoexInd->coexIndData[2],
13503 pSmeCoexInd->coexIndData[3]);
13504 }
13505 break;
13506 }
13507 case WDI_TX_COMPLETE_IND:
13508 {
13509 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13510 /* Calling TxCompleteAck Indication from wda context*/
13511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13512 "Complete Indication received from HAL");
13513 if( pWDA->pAckTxCbFunc )
13514 {
13515 if( VOS_STATUS_SUCCESS !=
13516 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13517 {
13518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13519 "Tx Complete timeout Timer Stop Failed ");
13520 }
13521 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13522 pWDA->pAckTxCbFunc = NULL;
13523 }
13524 else
13525 {
13526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13527 "Tx Complete Indication is received after timeout ");
13528 }
13529 break;
13530 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13531 case WDI_P2P_NOA_START_IND :
13532 {
13533 tSirP2PNoaStart *pP2pNoaStart =
13534 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13535
13536 if (NULL == pP2pNoaStart)
13537 {
13538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13539 "Memory allocation failure, "
13540 "WDI_P2P_NOA_START_IND not forwarded");
13541 break;
13542 }
13543 pP2pNoaStart->status =
13544 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13545 pP2pNoaStart->bssIdx =
13546 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13547 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13548 (void *)pP2pNoaStart , 0) ;
13549 break;
13550 }
13551
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13552#ifdef FEATURE_WLAN_TDLS
13553 case WDI_TDLS_IND :
13554 {
13555 tSirTdlsInd *pTdlsInd =
13556 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13557
13558 if (NULL == pTdlsInd)
13559 {
13560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13561 "Memory allocation failure, "
13562 "WDI_TDLS_IND not forwarded");
13563 break;
13564 }
13565 pTdlsInd->status =
13566 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13567 pTdlsInd->assocId =
13568 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13569 pTdlsInd->staIdx =
13570 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13571 pTdlsInd->reasonCode =
13572 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13573 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13574 (void *)pTdlsInd , 0) ;
13575 break;
13576 }
13577#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13578 case WDI_P2P_NOA_ATTR_IND :
13579 {
13580 tSirP2PNoaAttr *pP2pNoaAttr =
13581 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13583 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13584 if (NULL == pP2pNoaAttr)
13585 {
13586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13587 "Memory allocation failure, "
13588 "WDI_P2P_NOA_ATTR_IND not forwarded");
13589 break;
13590 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13591 pP2pNoaAttr->index =
13592 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13593 pP2pNoaAttr->oppPsFlag =
13594 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13595 pP2pNoaAttr->ctWin =
13596 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13597
13598 pP2pNoaAttr->uNoa1IntervalCnt =
13599 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13600 pP2pNoaAttr->uNoa1Duration =
13601 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13602 pP2pNoaAttr->uNoa1Interval =
13603 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13604 pP2pNoaAttr->uNoa1StartTime =
13605 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13606 pP2pNoaAttr->uNoa2IntervalCnt =
13607 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13608 pP2pNoaAttr->uNoa2Duration =
13609 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13610 pP2pNoaAttr->uNoa2Interval =
13611 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13612 pP2pNoaAttr->uNoa2StartTime =
13613 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13614 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13615 (void *)pP2pNoaAttr , 0) ;
13616 break;
13617 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13618#ifdef FEATURE_WLAN_SCAN_PNO
13619 case WDI_PREF_NETWORK_FOUND_IND:
13620 {
13621 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13622 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13623 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13624 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13625 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13626
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13628 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13629 if (NULL == pPrefNetworkFoundInd)
13630 {
13631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13632 "Memory allocation failure, "
13633 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13634 if (NULL !=
13635 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13636 {
13637 wpalMemoryFree(
13638 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13639 );
13640 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13641 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13642 break;
13643 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13644 /* Message Header */
13645 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13646 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13647
13648 /* Info from WDI Indication */
13649 pPrefNetworkFoundInd->ssId.length =
13650 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13651 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13652 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13653 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13654 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13655 if (NULL !=
13656 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13657 {
13658 pPrefNetworkFoundInd->frameLength =
13659 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13660 vos_mem_copy( pPrefNetworkFoundInd->data,
13661 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13662 pPrefNetworkFoundInd->frameLength);
13663 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13664 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13665 }
13666 else
13667 {
13668 pPrefNetworkFoundInd->frameLength = 0;
13669 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13670 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13671 /* VOS message wrapper */
13672 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13673 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13674 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13675 /* Send message to SME */
13676 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13677 {
13678 /* free the mem and return */
13679 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13680 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13681 break;
13682 }
13683#endif // FEATURE_WLAN_SCAN_PNO
13684
13685#ifdef WLAN_WAKEUP_EVENTS
13686 case WDI_WAKE_REASON_IND:
13687 {
13688 vos_msg_t vosMsg;
13689 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13690 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13691 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13692
13693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13694 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13695 wdiLowLevelInd->wdiIndicationType,
13696 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13697 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13698 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13699
13700 if (NULL == pWakeReasonInd)
13701 {
13702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13703 "Memory allocation failure, "
13704 "WDI_WAKE_REASON_IND not forwarded");
13705 break;
13706 }
13707
13708 vos_mem_zero(pWakeReasonInd, allocSize);
13709
13710 /* Message Header */
13711 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13712 pWakeReasonInd->mesgLen = allocSize;
13713
13714 /* Info from WDI Indication */
13715 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13716 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13717 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13718 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13719 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13720 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13721 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13722 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13723
13724 /* VOS message wrapper */
13725 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13726 vosMsg.bodyptr = (void *) pWakeReasonInd;
13727 vosMsg.bodyval = 0;
13728
13729 /* Send message to SME */
13730 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13731 {
13732 /* free the mem and return */
13733 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13734 }
13735
13736 break;
13737 }
13738#endif // WLAN_WAKEUP_EVENTS
13739
13740 case WDI_TX_PER_HIT_IND:
13741 {
13742 vos_msg_t vosMsg;
13743 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13744 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13745 /* VOS message wrapper */
13746 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13747 vosMsg.bodyptr = NULL;
13748 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13749 /* Send message to SME */
13750 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13751 {
13752 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13753 }
13754 break;
13755 }
13756
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13757#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13758 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13759 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13760 vos_msg_t vosMsg;
13761 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13762
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13763 lphbInd =
13764 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13765 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13766 {
13767 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13768 "%s: LPHB IND buffer alloc Fail", __func__);
13769 return ;
13770 }
13771
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13772 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13773 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13774 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13775 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13776 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13777 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13778
13779 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13780 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13781 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13782
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13783 vosMsg.type = eWNI_SME_LPHB_IND;
13784 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13785 vosMsg.bodyval = 0;
13786 /* Send message to SME */
13787 if (VOS_STATUS_SUCCESS !=
13788 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13789 {
13790 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13791 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13792 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13793 }
13794 break;
13795 }
13796#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13797 case WDI_PERIODIC_TX_PTRN_FW_IND:
13798 {
13799 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13800 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13801 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13802 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13803 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13804 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13805 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13806
13807 break;
13808 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13809
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13810 case WDI_IBSS_PEER_INACTIVITY_IND:
13811 {
13812 tSirIbssPeerInactivityInd *pIbssInd =
13813 (tSirIbssPeerInactivityInd *)
13814 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13815
13816 if (NULL == pIbssInd)
13817 {
13818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13819 "Memory allocation failure, "
13820 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13821 break;
13822 }
13823
13824 pIbssInd->bssIdx =
13825 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13826 pIbssInd->staIdx =
13827 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13828 vos_mem_copy(pIbssInd->peerAddr,
13829 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13830 sizeof(tSirMacAddr));
13831 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13832 break;
13833 }
13834
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13835#ifdef FEATURE_WLAN_BATCH_SCAN
13836 case WDI_BATCH_SCAN_RESULT_IND:
13837 {
13838 void *pBatchScanResult;
13839 void *pCallbackContext;
13840 tpAniSirGlobal pMac;
13841
13842 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13843 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13844
13845 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13846 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13847 {
13848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13849 "%s:pWDA is NULL", __func__);
13850 VOS_ASSERT(0);
13851 return;
13852 }
13853
13854 pBatchScanResult =
13855 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13856 if (NULL == pBatchScanResult)
13857 {
13858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13859 "%s:Batch scan result from FW is null can't invoke HDD callback",
13860 __func__);
13861 VOS_ASSERT(0);
13862 return;
13863 }
13864
13865 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13866 if (NULL == pMac)
13867 {
13868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13869 "%s:pMac is NULL", __func__);
13870 VOS_ASSERT(0);
13871 return;
13872 }
13873
13874 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13875 /*call hdd callback with set batch scan response data*/
13876 if(pMac->pmc.batchScanResultCallback)
13877 {
13878 pMac->pmc.batchScanResultCallback(pCallbackContext,
13879 pBatchScanResult);
13880 }
13881 else
13882 {
13883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13884 "%s:HDD callback is null", __func__);
13885 VOS_ASSERT(0);
13886 }
13887 break;
13888 }
13889#endif
13890
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13891#ifdef FEATURE_WLAN_CH_AVOID
13892 case WDI_CH_AVOID_IND:
13893 {
13894 vos_msg_t vosMsg;
13895 tSirChAvoidIndType *chAvoidInd;
13896
13897 chAvoidInd =
13898 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13899 if (NULL == chAvoidInd)
13900 {
13901 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13902 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13903 return ;
13904 }
13905
13906 chAvoidInd->avoidRangeCount =
13907 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13908 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13909 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13910 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13911
13912 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13913 "%s : WDA CH avoid notification", __func__);
13914
13915 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13916 vosMsg.bodyptr = chAvoidInd;
13917 vosMsg.bodyval = 0;
13918 /* Send message to SME */
13919 if (VOS_STATUS_SUCCESS !=
13920 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13921 {
13922 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13923 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13924 vos_mem_free(chAvoidInd);
13925 }
13926 break;
13927 }
13928#endif /* FEATURE_WLAN_CH_AVOID */
13929
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13930#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13931 case WDI_LL_STATS_RESULTS_IND:
13932 {
13933 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13934 tpAniSirGlobal pMac;
13935
13936 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13937 "Received WDI_LL_STATS_RESULTS_IND from FW");
13938
13939 /*sanity check*/
13940 if (NULL == pWDA)
13941 {
13942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13943 "%s:pWDA is NULL", __func__);
13944 VOS_ASSERT(0);
13945 return;
13946 }
13947
13948 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13949 (void *)wdiLowLevelInd->
13950 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13951 if (NULL == pLinkLayerStatsInd)
13952 {
13953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13954 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13955 __func__);
13956 VOS_ASSERT(0);
13957 return;
13958 }
13959
13960 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13961 if (NULL == pMac)
13962 {
13963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13964 "%s:pMac is NULL", __func__);
13965 VOS_ASSERT(0);
13966 return;
13967 }
13968
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13969 /* call hdd callback with Link Layer Statistics.
13970 * vdev_id/ifacId in link_stats_results will be
13971 * used to retrieve the correct HDD context
13972 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13973 if (pMac->sme.pLinkLayerStatsIndCallback)
13974 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13975 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13976 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13977 pLinkLayerStatsInd,
13978 wdiLowLevelInd->
13979 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13980 }
13981 else
13982 {
13983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13984 "%s:HDD callback is null", __func__);
13985 }
13986 break;
13987 }
13988#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13989
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13990#ifdef WLAN_FEATURE_EXTSCAN
13991 case WDI_EXTSCAN_PROGRESS_IND:
13992 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13993 case WDI_EXTSCAN_SCAN_RESULT_IND:
13994 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13995 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13996 {
13997 void *pEXTScanData;
13998 void *pCallbackContext;
13999 tpAniSirGlobal pMac;
14000 tANI_U16 indType;
14001
14002 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14003 "Received WDI_EXTSCAN Indications from FW");
14004 /*sanity check*/
14005 if (NULL == pWDA)
14006 {
14007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14008 "%s:pWDA is NULL", __func__);
14009 VOS_ASSERT(0);
14010 return;
14011 }
14012 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
14013 {
14014 indType = WDA_EXTSCAN_PROGRESS_IND;
14015
14016 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14017 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
14018 }
14019 if (wdiLowLevelInd->wdiIndicationType ==
14020 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
14021 {
14022 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
14023
14024 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14025 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
14026 }
14027 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
14028 {
14029 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
14030
14031 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14032 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
14033 }
14034 if (wdiLowLevelInd->wdiIndicationType ==
14035 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
14036 {
14037 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
14038
14039 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14040 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
14041 }
14042 if (wdiLowLevelInd->wdiIndicationType ==
14043 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
14044 {
14045 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
14046
14047 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14048 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
14049 }
14050
14051 pEXTScanData =
14052 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
14053 if (NULL == pEXTScanData)
14054 {
14055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14056 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
14057 __func__);
14058 VOS_ASSERT(0);
14059 return;
14060 }
14061
14062 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14063 if (NULL == pMac)
14064 {
14065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14066 "%s:pMac is NULL", __func__);
14067 VOS_ASSERT(0);
14068 return;
14069 }
14070
14071 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
14072
14073 if(pMac->sme.pEXTScanIndCb)
14074 {
14075 pMac->sme.pEXTScanIndCb(pCallbackContext,
14076 indType,
14077 pEXTScanData);
14078 }
14079 else
14080 {
14081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14082 "%s:HDD callback is null", __func__);
14083 }
14084 break;
14085 }
14086#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]14087 case WDI_DEL_BA_IND:
14088 {
14089 tpBADeleteParams pDelBAInd =
14090 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
14091
14092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14093 "Received WDI_DEL_BA_IND from WDI ");
14094 if(NULL == pDelBAInd)
14095 {
14096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14097 "%s: VOS MEM Alloc Failure", __func__);
14098 break;
14099 }
14100 vos_mem_copy(pDelBAInd->peerMacAddr,
14101 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
14102 sizeof(tSirMacAddr));
14103 vos_mem_copy(pDelBAInd->bssId,
14104 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
14105 sizeof(tSirMacAddr));
14106 pDelBAInd->staIdx =
14107 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
14108 pDelBAInd->baTID =
14109 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
14110 pDelBAInd->baDirection =
14111 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
14112 pDelBAInd->reasonCode =
14113 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
14114
14115 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
14116 (void *)pDelBAInd , 0) ;
14117 break;
14118 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14120 default:
14121 {
14122 /* TODO error */
14123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14124 "Received UNKNOWN Indication from WDI ");
14125 }
14126 }
14127 return ;
14128}
14129
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14130/*
14131 * BA related processing in WDA.
14132 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14133void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
14134 void* pUserData)
14135{
14136 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14137 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14138 if(NULL == pWdaParams)
14139 {
14140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14141 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14142 VOS_ASSERT(0) ;
14143 return ;
14144 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14145 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14146 vos_mem_free(pWdaParams->wdaMsgParam) ;
14147 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14148 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14150 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14151 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
14152 {
14153 tANI_U8 i = 0 ;
14154 tBaActivityInd *baActivityInd = NULL ;
14155 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
14156 tANI_U8 allocSize = sizeof(tBaActivityInd)
14157 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
14158 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
14159 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14160 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14161 if(NULL == baActivityInd)
14162 {
14163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14164 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14165 VOS_ASSERT(0) ;
14166 return;
14167 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14168 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
14169 sizeof(tSirMacAddr)) ;
14170 baActivityInd->baCandidateCnt = baCandidateCount ;
14171
14172 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
14173 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
14174
14175 for(i = 0 ; i < baCandidateCount ; i++)
14176 {
14177 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14178 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
14179 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14180 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
14181 {
14182 baCandidate->baInfo[tid].fBaEnable =
14183 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
14184 baCandidate->baInfo[tid].startingSeqNum =
14185 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
14186 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]14187 wdiBaCandidate++ ;
14188 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14189 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14190 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
14191 }
14192 else
14193 {
14194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14195 "BA Trigger RSP with Failure received ");
14196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14197 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14198}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14199
14200
14201/*
14202 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
14203 * during MCC
14204 */
14205void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
14206{
14207 wpt_uint32 enabled;
14208 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
14209 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
14210 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
14211
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14212 if (NULL == pMac )
14213 {
14214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14215 "%s: Invoked with invalid MAC context ", __func__ );
14216 VOS_ASSERT(0);
14217 return;
14218 }
14219
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14220 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14221 != eSIR_SUCCESS)
14222 {
14223 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14224 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14225 return;
14226 }
14227
14228 if(!enabled)
14229 {
14230 return;
14231 }
14232
14233 if(NULL == pWDA)
14234 {
14235 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14236 "%s:WDA context is NULL", __func__);
14237 VOS_ASSERT(0);
14238 return;
14239 }
14240
14241 if(activate)
14242 {
14243 if( VOS_STATUS_SUCCESS !=
14244 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14245 {
14246 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14247 "Traffic Stats Timer Start Failed ");
14248 return;
14249 }
14250 WDI_DS_ActivateTrafficStats();
14251 }
14252 else
14253 {
14254 WDI_DS_DeactivateTrafficStats();
14255 WDI_DS_ClearTrafficStats();
14256
14257 if( VOS_STATUS_SUCCESS !=
14258 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14259 {
14260 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14261 "Traffic Stats Timer Stop Failed ");
14262 return;
14263 }
14264 }
14265}
14266
14267/*
14268 * Traffic Stats Timer handler
14269 */
14270void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
14271{
14272 WDI_Status wdiStatus;
14273 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
14274 WDI_TrafficStatsIndType trafficStatsIndParams;
14275 wpt_uint32 length, enabled;
14276 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14277
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14278 if (NULL == pMac )
14279 {
14280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14281 "%s: Invoked with invalid MAC context ", __func__ );
14282 VOS_ASSERT(0);
14283 return;
14284 }
14285
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14286 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14287 != eSIR_SUCCESS)
14288 {
14289 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14290 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14291 return;
14292 }
14293
14294 if(!enabled)
14295 {
14296 WDI_DS_DeactivateTrafficStats();
14297 return;
14298 }
14299
14300 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
14301
14302 if(pWdiTrafficStats != NULL)
14303 {
14304 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
14305 trafficStatsIndParams.length = length;
14306 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]14307 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14308 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
14309 trafficStatsIndParams.pUserData = pWDA;
14310
14311 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
14312
14313 if(WDI_STATUS_PENDING == wdiStatus)
14314 {
14315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14316 "Pending received for %s:%d ",__func__,__LINE__ );
14317 }
14318 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
14319 {
14320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14321 "Failure in %s:%d ",__func__,__LINE__ );
14322 }
14323
14324 WDI_DS_ClearTrafficStats();
14325 }
14326 else
14327 {
14328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14329 "pWdiTrafficStats is Null");
14330 }
14331
14332 if( VOS_STATUS_SUCCESS !=
14333 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14334 {
14335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14336 "Traffic Stats Timer Start Failed ");
14337 return;
14338 }
14339}
14340
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14341/*
14342 * BA Activity check timer handler
14343 */
14344void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
14345{
14346 tANI_U8 curSta = 0 ;
14347 tANI_U8 tid = 0 ;
14348 tANI_U8 size = 0 ;
14349 tANI_U8 baCandidateCount = 0 ;
14350 tANI_U8 newBaCandidate = 0 ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14351 tANI_U32 val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14352 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14353 tpAniSirGlobal pMac;
14354
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14355 if(NULL == pWDA)
14356 {
14357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14358 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14359 VOS_ASSERT(0);
14360 return ;
14361 }
14362 if(WDA_MAX_STA < pWDA->wdaMaxSta)
14363 {
14364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14365 "Inconsistent STA entries in WDA");
14366 VOS_ASSERT(0) ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14367 }
14368 if(NULL == pWDA->pVosContext)
14369 {
14370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14371 "%s: pVosContext is NULL",__func__);
14372 VOS_ASSERT(0);
14373 return ;
14374 }
14375 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14376 if (wlan_cfgGetInt(pMac,
14377 WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC, &val) !=
14378 eSIR_SUCCESS)
14379 {
14380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14381 "Unable to get WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC");
14382 val = 0;
14383 }
14384
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14385 /* walk through all STA entries and find out TX packet count */
14386 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
14387 {
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14388 tANI_U32 currentOperChan = pWDA->wdaStaInfo[curSta].currentOperChan;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14389#ifdef WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14390 // We can only do BA on "hard" STAs.
14391 if (!(IS_HWSTA_IDX(curSta)))
14392 {
14393 continue;
14394 }
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14395#endif //WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14396 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
14397 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14398 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14399 tANI_U32 txPktCount = 0 ;
14400 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14401 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14402 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
14403 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14404 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14405 curSta, tid, &txPktCount)))
14406 {
14407#if 0
14408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14409 "************* %d:%d, %d ",curSta, txPktCount,
14410 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14411#endif
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14412 if(val && ( (currentOperChan >= SIR_11B_CHANNEL_BEGIN) &&
14413 (currentOperChan <= SIR_11B_CHANNEL_END)))
14414 {
14415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14416 "%s: BTC disabled aggregation - dont start "
14417 "TX ADDBA req",__func__);
14418 }
14419 else if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14420 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14421 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14422 curSta, tid)))
14423 {
14424 /* get prepare for sending message to HAL */
14425 //baCandidate[baCandidateCount].staIdx = curSta ;
14426 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14427 newBaCandidate = WDA_ENABLE_BA ;
14428 }
14429 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14430 }
14431 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14432 /* fill the entry for all the sta with given TID's */
14433 if(WDA_ENABLE_BA == newBaCandidate)
14434 {
14435 /* move to next BA candidate */
14436 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14437 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14438 baCandidateCount++ ;
14439 newBaCandidate = WDA_DISABLE_BA ;
14440 }
14441 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14442 /* prepare and send message to hal */
14443 if( 0 < baCandidateCount)
14444 {
14445 WDI_Status status = WDI_STATUS_SUCCESS ;
14446 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14447 tWDA_ReqParams *pWdaParams =
14448 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14449 if(NULL == pWdaParams)
14450 {
14451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14452 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14453 VOS_ASSERT(0) ;
14454 return;
14455 }
14456 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14457 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14458 if(NULL == wdiTriggerBaReq)
14459 {
14460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14461 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14462 VOS_ASSERT(0) ;
14463 vos_mem_free(pWdaParams);
14464 return;
14465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14466 do
14467 {
14468 WDI_TriggerBAReqinfoType *triggerBaInfo =
14469 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14470 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14471 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14472 * for each request */
14473 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14474 triggerBaInfo->ucBASessionID = 0;
14475 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14476 } while(0) ;
14477 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14479 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14480 pWdaParams->pWdaContext = pWDA;
14481 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14482 pWdaParams->wdaMsgParam = NULL;
14483 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14484 WDA_TriggerBaReqCallback, pWdaParams) ;
14485 if(IS_WDI_STATUS_FAILURE(status))
14486 {
14487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14488 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14489 vos_mem_free(pWdaParams->wdaMsgParam) ;
14490 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14491 vos_mem_free(pWdaParams) ;
14492 }
14493 }
14494 else
14495 {
14496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14497 "There is no TID for initiating BA");
14498 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14499 if( VOS_STATUS_SUCCESS !=
14500 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14501 {
14502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14503 "BA Activity Timer Stop Failed ");
14504 return ;
14505 }
14506 if( VOS_STATUS_SUCCESS !=
14507 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14508 {
14509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14510 "BA Activity Timer Start Failed ");
14511 return;
14512 }
14513 return ;
14514}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14515/*
14516 * WDA common routine to create timer used by WDA.
14517 */
14518static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14519{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14520 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14521 tANI_U32 val = 0 ;
14522 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14523
14524 if(NULL == pMac)
14525 {
14526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14527 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14528 VOS_ASSERT(0);
14529 return VOS_STATUS_E_FAILURE;
14530 }
14531 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14532 != eSIR_SUCCESS)
14533 {
14534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14535 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14536 return VOS_STATUS_E_FAILURE;
14537 }
14538 val = SYS_MS_TO_TICKS(val) ;
14539
14540 /* BA activity check timer */
14541 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14542 "BA Activity Check timer", WDA_TimerHandler,
14543 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14544 if(status != TX_SUCCESS)
14545 {
14546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14547 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14548 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14549 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14550 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14551 /* Tx Complete Timeout timer */
14552 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14553 "Tx Complete Check timer", WDA_TimerHandler,
14554 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14555 if(status != TX_SUCCESS)
14556 {
14557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14558 "Unable to create Tx Complete Timeout timer");
14559 /* Destroy timer of BA activity check timer */
14560 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14561 if(status != TX_SUCCESS)
14562 {
14563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14564 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14565 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14566 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14567 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14568 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14569
14570 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14571
14572 /* Traffic Stats timer */
14573 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14574 "Traffic Stats timer", WDA_TimerHandler,
14575 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14576 if(status != TX_SUCCESS)
14577 {
14578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14579 "Unable to create traffic stats timer");
14580 /* Destroy timer of BA activity check timer */
14581 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14582 if(status != TX_SUCCESS)
14583 {
14584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14585 "Unable to Destroy BA activity timer");
14586 }
14587 /* Destroy timer of tx complete timer */
14588 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14589 if(status != TX_SUCCESS)
14590 {
14591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14592 "Unable to Tx complete timer");
14593 }
14594 return VOS_STATUS_E_FAILURE ;
14595 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14596 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14597}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14598/*
14599 * WDA common routine to destroy timer used by WDA.
14600 */
14601static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14602{
14603 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14604 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14605 if(status != TX_SUCCESS)
14606 {
14607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14608 "Unable to Destroy Tx Complete Timeout timer");
14609 return eSIR_FAILURE ;
14610 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14611 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14612 if(status != TX_SUCCESS)
14613 {
14614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14615 "Unable to Destroy BA activity timer");
14616 return eSIR_FAILURE ;
14617 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14618 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14619 if(status != TX_SUCCESS)
14620 {
14621 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14622 "Unable to Destroy traffic stats timer");
14623 return eSIR_FAILURE ;
14624 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14625 return eSIR_SUCCESS ;
14626}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14627/*
14628 * WDA timer handler.
14629 */
14630void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14631{
14632 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14633 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14634 /*
14635 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14636 */
14637 wdaMsg.type = timerInfo ;
14638 wdaMsg.bodyptr = NULL;
14639 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14640 /* post the message.. */
14641 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14642 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14643 {
14644 vosStatus = VOS_STATUS_E_BADMSG;
14645 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14646}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14647/*
14648 * WDA Tx Complete timeout Indication.
14649 */
14650void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14651{
14652 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14653 if( pWDA->pAckTxCbFunc )
14654 {
14655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14656 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14657 pWDA->pAckTxCbFunc( pMac, 0);
14658 pWDA->pAckTxCbFunc = NULL;
14659 }
14660 else
14661 {
14662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14663 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14664 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14665}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14666/*
14667 * WDA Set REG Domain to VOS NV
14668 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14669eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14670 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14671{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14672 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14673 {
14674 return eHAL_STATUS_INVALID_PARAMETER;
14675 }
14676 return eHAL_STATUS_SUCCESS;
14677}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14678
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14679#ifdef FEATURE_WLAN_SCAN_PNO
14680/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14681 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14682 *
14683 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14684void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14685{
14686 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14687 tSirPNOScanReq *pPNOScanReqParams;
14688
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14690 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14691 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14692 {
14693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14694 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14695 VOS_ASSERT(0) ;
14696 return ;
14697 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14698
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14699 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14700 if(pPNOScanReqParams->statusCallback)
14701 {
14702 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14703 (status == WDI_STATUS_SUCCESS) ?
14704 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14705 }
14706
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14707 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14708 vos_mem_free(pWdaParams->wdaMsgParam);
14709 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14710
14711 return ;
14712}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14713/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14714 * FUNCTION: WDA_PNOScanReqCallback
14715 * Free memory.
14716 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14717 */
14718void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14719{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14720 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14721 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14722
14723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14724 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14725
14726 if(NULL == pWdaParams)
14727 {
14728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14729 "%s: pWdaParams received NULL", __func__);
14730 VOS_ASSERT(0);
14731 return;
14732 }
14733
14734 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14735 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14736 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14737 if(pPNOScanReqParams->statusCallback)
14738 {
14739 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14740 VOS_STATUS_E_FAILURE);
14741 }
14742
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14743 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14744 vos_mem_free(pWdaParams->wdaMsgParam);
14745 vos_mem_free(pWdaParams);
14746 }
14747
14748 return;
14749}
14750/*
14751 * FUNCTION: WDA_UpdateScanParamsRespCallback
14752 *
14753 */
14754void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14755{
14756 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14758 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14759 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14760 {
14761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14762 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14763 VOS_ASSERT(0) ;
14764 return ;
14765 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14766
14767 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14768 vos_mem_free(pWdaParams->wdaMsgParam);
14769 vos_mem_free(pWdaParams);
14770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14771 return ;
14772}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14773/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14774 * FUNCTION: WDA_UpdateScanParamsReqCallback
14775 * Free memory.
14776 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14777 */
14778void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14779{
14780 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14781
14782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14783 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14784
14785 if(NULL == pWdaParams)
14786 {
14787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14788 "%s: pWdaParams received NULL", __func__);
14789 VOS_ASSERT(0);
14790 return;
14791 }
14792
14793 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14794 {
14795 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14796 vos_mem_free(pWdaParams->wdaMsgParam);
14797 vos_mem_free(pWdaParams);
14798 }
14799
14800 return;
14801}
14802/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14803 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14804 * Request to WDI to set Preferred Network List.Offload
14805 */
14806VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14807 tSirPNOScanReq *pPNOScanReqParams)
14808{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14809 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14810 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14811 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14812 tWDA_ReqParams *pWdaParams ;
14813 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14815 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14816 if(NULL == pwdiPNOScanReqInfo)
14817 {
14818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14819 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14820 VOS_ASSERT(0);
14821 return VOS_STATUS_E_NOMEM;
14822 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14823 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14824 if(NULL == pWdaParams)
14825 {
14826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14827 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14828 VOS_ASSERT(0);
14829 vos_mem_free(pwdiPNOScanReqInfo);
14830 return VOS_STATUS_E_NOMEM;
14831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14832 //
14833 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14834 //
14835 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14836 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14837 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14838 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14839 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14840 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14841 {
14842 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14843 &pPNOScanReqParams->aNetworks[i],
14844 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14845 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14846 /*Scan timer intervals*/
14847 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14848 &pPNOScanReqParams->scanTimers,
14849 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14850 /*Probe template for 2.4GHz band*/
14851 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14852 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14853 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14854 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14855 pPNOScanReqParams->p24GProbeTemplate,
14856 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14857 /*Probe template for 5GHz band*/
14858 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14859 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14860 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14861 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14862 pPNOScanReqParams->p5GProbeTemplate,
14863 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14864 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14865 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14866
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14867 /* Store Params pass it to WDI */
14868 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14869 pWdaParams->pWdaContext = pWDA;
14870 /* Store param pointer as passed in by caller */
14871 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14872 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14873 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14874 if(IS_WDI_STATUS_FAILURE(status))
14875 {
14876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14877 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14878 if(pPNOScanReqParams->statusCallback)
14879 {
14880 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14881 VOS_STATUS_E_FAILURE);
14882 }
14883
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14884 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14885 vos_mem_free(pWdaParams->wdaMsgParam);
14886 pWdaParams->wdaWdiApiMsgParam = NULL;
14887 pWdaParams->wdaMsgParam = NULL;
14888 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14889 return CONVERT_WDI2VOS_STATUS(status) ;
14890}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14891
14892#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14893
14894void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14895{
14896 /*Convert the CSR Auth types to WDI Auth types */
14897 switch (csrAuthType)
14898 {
14899 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14900 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14901 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14902#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14903 case eCSR_AUTH_TYPE_CCKM_WPA:
14904 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14905 break;
14906#endif
14907 case eCSR_AUTH_TYPE_WPA:
14908 *AuthType = eWDA_AUTH_TYPE_WPA;
14909 break;
14910 case eCSR_AUTH_TYPE_WPA_PSK:
14911 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14912 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14913#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14914 case eCSR_AUTH_TYPE_CCKM_RSN:
14915 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14916 break;
14917#endif
14918 case eCSR_AUTH_TYPE_RSN:
14919 *AuthType = eWDA_AUTH_TYPE_RSN;
14920 break;
14921 case eCSR_AUTH_TYPE_RSN_PSK:
14922 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14923 break;
14924#if defined WLAN_FEATURE_VOWIFI_11R
14925 case eCSR_AUTH_TYPE_FT_RSN:
14926 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14927 break;
14928 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14929 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14930 break;
14931#endif
14932#ifdef FEATURE_WLAN_WAPI
14933 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14934 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14935 break;
14936 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14937 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14938 break;
14939#endif /* FEATURE_WLAN_WAPI */
14940 case eCSR_AUTH_TYPE_SHARED_KEY:
14941 case eCSR_AUTH_TYPE_AUTOSWITCH:
14942 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14943 break;
14944#if 0
14945 case eCSR_AUTH_TYPE_SHARED_KEY:
14946 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14947 break;
14948 case eCSR_AUTH_TYPE_AUTOSWITCH:
14949 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14950#endif
14951 default:
14952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14953 "%s: Unknown Auth Type", __func__);
14954 break;
14955 }
14956}
14957void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14958{
14959 switch (csrEncrType)
14960 {
14961 case eCSR_ENCRYPT_TYPE_NONE:
14962 *EncrType = WDI_ED_NONE;
14963 break;
14964 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14965 case eCSR_ENCRYPT_TYPE_WEP40:
14966 *EncrType = WDI_ED_WEP40;
14967 break;
14968 case eCSR_ENCRYPT_TYPE_WEP104:
14969 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14970 *EncrType = WDI_ED_WEP104;
14971 break;
14972 case eCSR_ENCRYPT_TYPE_TKIP:
14973 *EncrType = WDI_ED_TKIP;
14974 break;
14975 case eCSR_ENCRYPT_TYPE_AES:
14976 *EncrType = WDI_ED_CCMP;
14977 break;
14978#ifdef WLAN_FEATURE_11W
14979 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14980 *EncrType = WDI_ED_AES_128_CMAC;
14981 break;
14982#endif
14983#ifdef FEATURE_WLAN_WAPI
14984 case eCSR_ENCRYPT_TYPE_WPI:
14985 *EncrType = WDI_ED_WPI;
14986 break;
14987#endif
14988 case eCSR_ENCRYPT_TYPE_ANY:
14989 *EncrType = WDI_ED_ANY;
14990 break;
14991
14992 default:
14993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14994 "%s: Unknown Encryption Type", __func__);
14995 break;
14996 }
14997}
14998
14999/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15000 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15001 * Request to WDI to set Roam Offload Scan
15002 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15003VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15004 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
15005{
15006 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15007 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
15008 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15009 tWDA_ReqParams *pWdaParams ;
15010 v_U8_t csrAuthType;
15011 WDI_RoamNetworkType *pwdiRoamNetworkType;
15012 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
15013 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15014 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15015 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15016 {
15017 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15018 "%s: VOS MEM Alloc Failure", __func__);
15019 VOS_ASSERT(0);
15020 return VOS_STATUS_E_NOMEM;
15021 }
15022 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15023 if (NULL == pWdaParams)
15024 {
15025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15026 "%s: VOS MEM Alloc Failure", __func__);
15027 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15028 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15029 return VOS_STATUS_E_NOMEM;
15030 }
15031
15032 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15033 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15034 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15035 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
15036 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15037 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
15038 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
15039 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
15040 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
15041 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
15042 sizeof(pwdiRoamNetworkType->currAPbssid));
15043 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
15044 csrAuthType);
15045 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
15046 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
15047 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
15048 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
15049 pwdiRoamOffloadScanInfo->LookupThreshold =
15050 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]15051 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
15052 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15053 pwdiRoamOffloadScanInfo->RoamRssiDiff =
15054 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]15055 pwdiRoamOffloadScanInfo->MAWCEnabled =
15056 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15057 pwdiRoamOffloadScanInfo->Command =
15058 pRoamOffloadScanReqParams->Command ;
15059 pwdiRoamOffloadScanInfo->StartScanReason =
15060 pRoamOffloadScanReqParams->StartScanReason ;
15061 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
15062 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
15063 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
15064 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
15065 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
15066 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
15067 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
15068 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
15069 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
15070 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]15071 pwdiRoamOffloadScanInfo->IsESEEnabled =
15072 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15073 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
15074 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
15075 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
15076 pwdiRoamNetworkType->ssId.ucLength =
15077 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
15078 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
15079 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
15080 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
15081 pwdiRoamNetworkType->ChannelCount =
15082 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
15083 pwdiRoamOffloadScanInfo->ChannelCacheType =
15084 pRoamOffloadScanReqParams->ChannelCacheType;
15085 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
15086 pRoamOffloadScanReqParams->ValidChannelList,
15087 pRoamOffloadScanReqParams->ValidChannelCount);
15088 pwdiRoamOffloadScanInfo->ValidChannelCount =
15089 pRoamOffloadScanReqParams->ValidChannelCount;
15090 pwdiRoamOffloadScanInfo->us24GProbeSize =
15091 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15092 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15093 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
15094 pRoamOffloadScanReqParams->p24GProbeTemplate,
15095 pwdiRoamOffloadScanInfo->us24GProbeSize);
15096 pwdiRoamOffloadScanInfo->us5GProbeSize =
15097 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15098 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15099 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
15100 pRoamOffloadScanReqParams->p5GProbeTemplate,
15101 pwdiRoamOffloadScanInfo->us5GProbeSize);
15102 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
15103 pRoamOffloadScanReqParams->MDID.mdiePresent;
15104 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
15105 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15106 pwdiRoamOffloadScanInfo->nProbes =
15107 pRoamOffloadScanReqParams->nProbes;
15108 pwdiRoamOffloadScanInfo->HomeAwayTime =
15109 pRoamOffloadScanReqParams->HomeAwayTime;
15110 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15111 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15112 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15113 pWdaParams->pWdaContext = pWDA;
15114 /* Store param pointer as passed in by caller */
15115 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15116 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15117 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
15118 if(IS_WDI_STATUS_FAILURE(status))
15119 {
15120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15121 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
15122 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15123 vos_mem_free(pWdaParams->wdaMsgParam);
15124 pWdaParams->wdaWdiApiMsgParam = NULL;
15125 pWdaParams->wdaMsgParam = NULL;
15126 }
15127 return CONVERT_WDI2VOS_STATUS(status) ;
15128}
15129#endif
15130
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15131/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15132 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15133 *
15134 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15135void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15136{
15137 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15138
15139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15140 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15141
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15142 if(NULL == pWdaParams)
15143 {
15144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15145 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15146 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15147 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15148 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15149
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15150 vos_mem_free(pWdaParams->wdaMsgParam) ;
15151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15152 vos_mem_free(pWdaParams) ;
15153
15154 return ;
15155}
15156/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15157 * FUNCTION: WDA_RssiFilterReqCallback
15158 * Free memory.
15159 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
15160 */
15161void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15162{
15163 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15164
15165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15166 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15167
15168 if(NULL == pWdaParams)
15169 {
15170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15171 "%s: pWdaParams received NULL", __func__);
15172 VOS_ASSERT(0);
15173 return;
15174 }
15175
15176 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15177 {
15178 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15179 vos_mem_free(pWdaParams->wdaMsgParam);
15180 vos_mem_free(pWdaParams);
15181 }
15182
15183 return;
15184}
15185/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15186 * FUNCTION: WDA_ProcessSetPreferredNetworkList
15187 * Request to WDI to set Preferred Network List.Offload
15188 */
15189VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
15190 tSirSetRSSIFilterReq* pRssiFilterParams)
15191{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15192 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15193 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
15194 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
15195 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15197 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15198 if(NULL == pwdiSetRssiFilterReqInfo)
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 return VOS_STATUS_E_NOMEM;
15204 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15205 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15206 if(NULL == pWdaParams)
15207 {
15208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15209 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15210 VOS_ASSERT(0);
15211 vos_mem_free(pwdiSetRssiFilterReqInfo);
15212 return VOS_STATUS_E_NOMEM;
15213 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15214 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15215 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
15216 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15217
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15218 /* Store Params pass it to WDI */
15219 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
15220 pWdaParams->pWdaContext = pWDA;
15221 /* Store param pointer as passed in by caller */
15222 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15223 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15224 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15225 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15226 if(IS_WDI_STATUS_FAILURE(status))
15227 {
15228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15229 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
15230 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15231 vos_mem_free(pWdaParams->wdaMsgParam);
15232 pWdaParams->wdaWdiApiMsgParam = NULL;
15233 pWdaParams->wdaMsgParam = NULL;
15234 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15235 return CONVERT_WDI2VOS_STATUS(status) ;
15236}
15237
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15238/*
15239 * FUNCTION: WDA_ProcessUpdateScanParams
15240 * Request to WDI to update Scan Parameters
15241 */
15242VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
15243 tSirUpdateScanParams *pUpdateScanParams)
15244{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15245 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15246 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
15247 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
15248 sizeof(WDI_UpdateScanParamsInfoType)) ;
15249 tWDA_ReqParams *pWdaParams ;
15250 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15252 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15253 if(NULL == wdiUpdateScanParamsInfoType)
15254 {
15255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15256 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15257 VOS_ASSERT(0);
15258 return VOS_STATUS_E_NOMEM;
15259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15260 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15261 if ( NULL == pWdaParams )
15262 {
15263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15264 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15265 VOS_ASSERT(0);
15266 vos_mem_free(wdiUpdateScanParamsInfoType);
15267 return VOS_STATUS_E_NOMEM;
15268 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15269 //
15270 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
15271 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15273 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
15274 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
15275 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]15276 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15277 pUpdateScanParams->b11dEnabled,
15278 pUpdateScanParams->b11dResolved,
15279 pUpdateScanParams->ucChannelCount,
15280 pUpdateScanParams->usPassiveMinChTime,
15281 pUpdateScanParams->usPassiveMaxChTime,
15282 pUpdateScanParams->usActiveMinChTime,
15283 pUpdateScanParams->usActiveMaxChTime,
15284 sizeof(tSirUpdateScanParams),
15285 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
15286
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15287 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
15288 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15289 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
15290 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15291 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
15292 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15293 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
15294 pUpdateScanParams->usActiveMaxChTime;
15295 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
15296 pUpdateScanParams->usActiveMinChTime;
15297 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
15298 pUpdateScanParams->usPassiveMaxChTime;
15299 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
15300 pUpdateScanParams->usPassiveMinChTime;
15301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15302 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]15303 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
15304 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15305
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15306 for ( i = 0; i <
15307 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
15308 i++)
15309 {
15310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15311 "Update Scan Parameters channel: %d",
15312 pUpdateScanParams->aChannels[i]);
15313
15314 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
15315 pUpdateScanParams->aChannels[i];
15316 }
15317
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15318 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
15319 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15320
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15321 /* Store Params pass it to WDI */
15322 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
15323 pWdaParams->pWdaContext = pWDA;
15324 /* Store param pointer as passed in by caller */
15325 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15326
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15327
15328
15329 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15330 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15331 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15332 if(IS_WDI_STATUS_FAILURE(status))
15333 {
15334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15335 "Failure in Update Scan Params EQ WDI API, free all the memory " );
15336 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15337 vos_mem_free(pWdaParams->wdaMsgParam);
15338 vos_mem_free(pWdaParams);
15339 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15340 return CONVERT_WDI2VOS_STATUS(status) ;
15341}
15342#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15343
15344#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
15345/*
15346 * FUNCTION: WDA_RoamOffloadScanReqCallback
15347 *
15348 */
15349void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
15350{
15351 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15352 vos_msg_t vosMsg;
15353 wpt_uint8 reason = 0;
15354
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]15355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15356 "<------ %s " ,__func__);
15357 if (NULL == pWdaParams)
15358 {
15359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15360 "%s: pWdaParams received NULL", __func__);
15361 VOS_ASSERT(0) ;
15362 return ;
15363 }
15364 if ( pWdaParams != NULL )
15365 {
15366 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
15367 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15368 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15370 }
15371 if ( pWdaParams->wdaMsgParam != NULL)
15372 {
15373 vos_mem_free(pWdaParams->wdaMsgParam);
15374 }
15375
15376 vos_mem_free(pWdaParams) ;
15377 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15378 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
15379 vosMsg.bodyptr = NULL;
15380 if (WDI_STATUS_SUCCESS != status)
15381 {
15382 reason = 0;
15383 }
15384 vosMsg.bodyval = reason;
15385 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15386 {
15387 /* free the mem and return */
15388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]15389 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15390 }
15391
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15392 return ;
15393}
15394#endif
15395
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15396/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15397 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15398 *
15399 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15400void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15401{
15402 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15403
15404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15405 "<------ %s " ,__func__);
15406
15407 if(NULL == pWdaParams)
15408 {
15409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15410 "%s: pWdaParams received NULL", __func__);
15411 VOS_ASSERT(0);
15412 return;
15413 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15414
15415 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15416 vos_mem_free(pWdaParams->wdaMsgParam);
15417 vos_mem_free(pWdaParams);
15418
15419 return;
15420}
15421/*
15422 * FUNCTION: WDA_SetPowerParamsReqCallback
15423 * Free memory.
15424 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15425 */
15426void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15427{
15428 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15429
15430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15431 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15432
15433 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15434 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15436 "%s: pWdaParams received NULL", __func__);
15437 VOS_ASSERT(0);
15438 return;
15439 }
15440
15441 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15442 {
15443 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15444 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15445 vos_mem_free(pWdaParams);
15446 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15447
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15448 return;
15449}
15450
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15451#ifdef WLAN_FEATURE_PACKET_FILTERING
15452/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15453 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15454 *
15455 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15456void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15457 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15458 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15459{
15460 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15462 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15463 if(NULL == pWdaParams)
15464 {
15465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15466 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15467 VOS_ASSERT(0) ;
15468 return ;
15469 }
15470
15471 vos_mem_free(pWdaParams->wdaMsgParam) ;
15472 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15473 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15474 //print a msg, nothing else to do
15475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15476 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15477 return ;
15478}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15479/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15480 * FUNCTION: WDA_8023MulticastListReqCallback
15481 * Free memory.
15482 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15483 */
15484void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15485{
15486 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15487
15488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15489 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15490
15491 if(NULL == pWdaParams)
15492 {
15493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15494 "%s: pWdaParams received NULL", __func__);
15495 VOS_ASSERT(0);
15496 return;
15497 }
15498
15499 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15500 {
15501 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15502 vos_mem_free(pWdaParams->wdaMsgParam);
15503 vos_mem_free(pWdaParams);
15504 }
15505
15506 return;
15507}
15508/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15509 * FUNCTION: WDA_Process8023MulticastListReq
15510 * Request to WDI to add 8023 Multicast List
15511 */
15512VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15513 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15514{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15515 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15516 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15517 tWDA_ReqParams *pWdaParams ;
15518 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15520 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15521 pwdiFltPktSetMcListReqParamsType =
15522 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15523 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15524 ) ;
15525 if(NULL == pwdiFltPktSetMcListReqParamsType)
15526 {
15527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15528 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15529 return VOS_STATUS_E_NOMEM;
15530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15531 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15532 if(NULL == pWdaParams)
15533 {
15534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15535 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15536 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15537 return VOS_STATUS_E_NOMEM;
15538 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15539
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15540 //
15541 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15542 //
15543 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15544 pRcvFltMcAddrList->ulMulticastAddrCnt;
15545
15546 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15547 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15548 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15549 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15550
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15551 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15552 {
15553 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15554 &(pRcvFltMcAddrList->multicastAddr[i]),
15555 sizeof(tSirMacAddr));
15556 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15557 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15558 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15559
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15560 /* Store Params pass it to WDI */
15561 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15562 pWdaParams->pWdaContext = pWDA;
15563 /* Store param pointer as passed in by caller */
15564 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15565 status = WDI_8023MulticastListReq(
15566 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15567 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15568 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15569 if(IS_WDI_STATUS_FAILURE(status))
15570 {
15571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15572 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15573 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15574 vos_mem_free(pWdaParams->wdaMsgParam);
15575 vos_mem_free(pWdaParams);
15576 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15577 return CONVERT_WDI2VOS_STATUS(status) ;
15578}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15579/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15580 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15581 *
15582 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15583void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15584 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15585 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15586{
15587 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15589 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15590 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15591 if(NULL == pWdaParams)
15592 {
15593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15594 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15595 VOS_ASSERT(0) ;
15596 return ;
15597 }
15598
15599 vos_mem_free(pWdaParams->wdaMsgParam) ;
15600 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15601 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15602 //print a msg, nothing else to do
15603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15604 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15605 return ;
15606}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15607
15608/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15609 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15610 * Free memory.
15611 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15612 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15613void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15614 void* pUserData)
15615{
15616 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15617
15618 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15619 "<------ %s, wdiStatus: %d",
15620 __func__, wdiStatus);
15621
15622 if (NULL == pWdaParams)
15623 {
15624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15625 "%s: Invalid pWdaParams pointer", __func__);
15626 VOS_ASSERT(0);
15627 return;
15628 }
15629
15630 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15631 {
15632 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15633 vos_mem_free(pWdaParams->wdaMsgParam);
15634 vos_mem_free(pWdaParams);
15635 }
15636
15637 return;
15638}
15639
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15640/*
15641 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15642 * Request to WDI to set Receive Filters
15643 */
15644VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15645 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15646{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15647 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15648 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15649 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15650 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15651 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15652 tWDA_ReqParams *pWdaParams ;
15653 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15655 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15656 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15657 {
15658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15659 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15660 VOS_ASSERT(0);
15661 return VOS_STATUS_E_NOMEM;
15662 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15663 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15664 if(NULL == pWdaParams)
15665 {
15666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15667 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15668 VOS_ASSERT(0);
15669 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15670 return VOS_STATUS_E_NOMEM;
15671 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15672 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15673 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15674 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15675 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15676 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15677 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15678
15679 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15680 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15681
15682 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15683 "FID %d FT %d NParams %d CT %d",
15684 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15685 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15686 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15687 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15688 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15689 {
15690 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15691 &pRcvPktFilterCfg->paramsData[i],
15692 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15694 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15695 pwdiSetRcvPktFilterReqParamsType->
15696 wdiPktFilterCfg.paramsData[i].protocolLayer,
15697 pwdiSetRcvPktFilterReqParamsType->
15698 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15700 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15701 pwdiSetRcvPktFilterReqParamsType->
15702 wdiPktFilterCfg.paramsData[i].dataOffset,
15703 pwdiSetRcvPktFilterReqParamsType->
15704 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15706 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15707 pwdiSetRcvPktFilterReqParamsType->
15708 wdiPktFilterCfg.paramsData[i].compareData[0],
15709 pwdiSetRcvPktFilterReqParamsType->
15710 wdiPktFilterCfg.paramsData[i].compareData[1],
15711 pwdiSetRcvPktFilterReqParamsType->
15712 wdiPktFilterCfg.paramsData[i].compareData[2],
15713 pwdiSetRcvPktFilterReqParamsType->
15714 wdiPktFilterCfg.paramsData[i].compareData[3],
15715 pwdiSetRcvPktFilterReqParamsType->
15716 wdiPktFilterCfg.paramsData[i].compareData[4],
15717 pwdiSetRcvPktFilterReqParamsType->
15718 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15720 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15721 pwdiSetRcvPktFilterReqParamsType->
15722 wdiPktFilterCfg.paramsData[i].dataMask[0],
15723 pwdiSetRcvPktFilterReqParamsType->
15724 wdiPktFilterCfg.paramsData[i].dataMask[1],
15725 pwdiSetRcvPktFilterReqParamsType->
15726 wdiPktFilterCfg.paramsData[i].dataMask[2],
15727 pwdiSetRcvPktFilterReqParamsType->
15728 wdiPktFilterCfg.paramsData[i].dataMask[3],
15729 pwdiSetRcvPktFilterReqParamsType->
15730 wdiPktFilterCfg.paramsData[i].dataMask[4],
15731 pwdiSetRcvPktFilterReqParamsType->
15732 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15733 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15734 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15735 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15736 /* Store Params pass it to WDI */
15737 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15738 pWdaParams->pWdaContext = pWDA;
15739 /* Store param pointer as passed in by caller */
15740 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15741 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15742 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15743 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15744 if(IS_WDI_STATUS_FAILURE(status))
15745 {
15746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15747 "Failure in SetFilter(),free all the memory,status %d ",status);
15748 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15749 vos_mem_free(pWdaParams->wdaMsgParam);
15750 vos_mem_free(pWdaParams);
15751 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15752 return CONVERT_WDI2VOS_STATUS(status) ;
15753}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15754/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15755 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15756 *
15757 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15758void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15759 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15760 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15761{
15762 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15763 tWDA_CbContext *pWDA;
15764 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15765 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15766 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15767 tANI_U8 i;
15768 vos_msg_t vosMsg;
15769
15770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15771 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15772 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15773
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15774 if(NULL == pRcvFltPktMatchCntRsp)
15775 {
15776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15777 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15778 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15779 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15780 return ;
15781 }
15782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15783 if(NULL == pWdaParams)
15784 {
15785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15786 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15787 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15788 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15789 return ;
15790 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15791 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15792 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15793 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15794 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15795
15796 /* Message Header */
15797 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15798 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15799
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15800 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15801
15802 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15803 {
15804 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15805 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15806 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15807 /* VOS message wrapper */
15808 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15809 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15810 vosMsg.bodyval = 0;
15811 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15812 {
15813 /* free the mem and return */
15814 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15815 }
15816
15817 vos_mem_free(pWdaParams->wdaMsgParam) ;
15818 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15819 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15820
15821 return;
15822}
15823/*
15824 * FUNCTION: WDA_FilterMatchCountReqCallback
15825 * Free memory and send RSP back to SME.
15826 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15827 */
15828void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15829{
15830 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15831 vos_msg_t vosMsg;
15832
15833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15834 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15835
15836 if(NULL == pWdaParams)
15837 {
15838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15839 "%s: pWdaParams received NULL", __func__);
15840 VOS_ASSERT(0);
15841 return;
15842 }
15843
15844 /* VOS message wrapper */
15845 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15846 vosMsg.bodyptr = NULL;
15847 vosMsg.bodyval = 0;
15848
15849 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15850 {
15851 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15852 vos_mem_free(pWdaParams->wdaMsgParam);
15853 vos_mem_free(pWdaParams);
15854 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15855 }
15856
15857 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15858}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15859/*
15860 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15861 * Request to WDI to get PC Filter Match Count
15862 */
15863VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15864{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15865 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15866 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15867 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15868 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15870 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15871 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15872 {
15873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15874 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15875 VOS_ASSERT(0);
15876 return VOS_STATUS_E_NOMEM;
15877 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15878 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15879 if(NULL == pWdaParams)
15880 {
15881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15883 VOS_ASSERT(0);
15884 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15885 return VOS_STATUS_E_NOMEM;
15886 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15887
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15888 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15889 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15890
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15891 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15892 pRcvFltPktMatchRsp->bssId,
15893 sizeof(wpt_macAddr));
15894
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15895 /* Store Params pass it to WDI */
15896 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15897 pWdaParams->pWdaContext = pWDA;
15898 /* Store param pointer as passed in by caller */
15899 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15900 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15901 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15902 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15903 if(IS_WDI_STATUS_FAILURE(status))
15904 {
15905 /* failure returned by WDI API */
15906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15907 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15908 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15909 vos_mem_free(pWdaParams) ;
15910 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15911 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15913 return CONVERT_WDI2VOS_STATUS(status) ;
15914}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15915/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15916 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15917 *
15918 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15919void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15920 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15921 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15922{
15923 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15925 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15926/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15927 if(NULL == pWdaParams)
15928 {
15929 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15930 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15931 VOS_ASSERT(0) ;
15932 return ;
15933 }
15934
15935 vos_mem_free(pWdaParams->wdaMsgParam) ;
15936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15937 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15938 //print a msg, nothing else to do
15939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15940 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15941 return ;
15942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15943/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15944 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15945 * Free memory.
15946 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15947 */
15948void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15949{
15950 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15951
15952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15953 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15954
15955 if(NULL == pWdaParams)
15956 {
15957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15958 "%s: Invalid pWdaParams pointer", __func__);
15959 VOS_ASSERT(0);
15960 return;
15961 }
15962
15963 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15964 {
15965 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15966 vos_mem_free(pWdaParams->wdaMsgParam);
15967 vos_mem_free(pWdaParams);
15968 }
15969
15970 return;
15971}
15972/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15973 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15974 * Request to WDI to clear Receive Filters
15975 */
15976VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15977 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15978{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15979 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15980 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15981 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15982 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15984 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15985 if(NULL == pwdiRcvFltPktClearReqParamsType)
15986 {
15987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15988 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15989 VOS_ASSERT(0);
15990 return VOS_STATUS_E_NOMEM;
15991 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15992 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15993 if(NULL == pWdaParams)
15994 {
15995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15996 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15997 VOS_ASSERT(0);
15998 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15999 return VOS_STATUS_E_NOMEM;
16000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16001 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
16002 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16003 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
16004 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
16005 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
16006 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16007
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16008 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16009 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16010 /* Store Params pass it to WDI */
16011 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
16012 pWdaParams->pWdaContext = pWDA;
16013 /* Store param pointer as passed in by caller */
16014 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16015 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16016 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16017 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16018 if(IS_WDI_STATUS_FAILURE(status))
16019 {
16020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16021 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
16022 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]16023 vos_mem_free(pWdaParams->wdaMsgParam);
16024 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16025 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16026 return CONVERT_WDI2VOS_STATUS(status) ;
16027}
16028#endif // WLAN_FEATURE_PACKET_FILTERING
16029
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16030/*
16031 * FUNCTION: WDA_ProcessSetPowerParamsReq
16032 * Request to WDI to set power params
16033 */
16034VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
16035 tSirSetPowerParamsReq *pPowerParams)
16036{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]16037 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16038 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
16039 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16040 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16042 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16043 if(NULL == pwdiSetPowerParamsReqInfo)
16044 {
16045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16047 VOS_ASSERT(0);
16048 return VOS_STATUS_E_NOMEM;
16049 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16050 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16051 if(NULL == pWdaParams)
16052 {
16053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16054 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16055 VOS_ASSERT(0);
16056 vos_mem_free(pwdiSetPowerParamsReqInfo);
16057 return VOS_STATUS_E_NOMEM;
16058 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16059
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16060
16061 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
16062 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16063 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
16064 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16065 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
16066 pPowerParams->uListenInterval;
16067 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
16068 pPowerParams->uBcastMcastFilter;
16069 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
16070 pPowerParams->uEnableBET;
16071 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
16072 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]16073 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
16074 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16075 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
16076 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16077
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16078 /* Store Params pass it to WDI */
16079 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
16080 pWdaParams->pWdaContext = pWDA;
16081 /* Store param pointer as passed in by caller */
16082 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16083 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16084 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16085 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16086 if(IS_WDI_STATUS_FAILURE(status))
16087 {
16088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16089 "Failure in Set power params REQ WDI API, free all the memory " );
16090 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16091 vos_mem_free(pWdaParams->wdaMsgParam);
16092 pWdaParams->wdaWdiApiMsgParam = NULL;
16093 pWdaParams->wdaMsgParam = NULL;
16094 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16095 return CONVERT_WDI2VOS_STATUS(status) ;
16096}
16097
16098/*
16099 * FUNCTION: WDA_SetTmLevelRspCallback
16100 * Set TM Level response
16101 */
16102void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
16103{
16104 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16105
16106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16107 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16108
16109 if(NULL == pWdaParams)
16110 {
16111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16112 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16113 VOS_ASSERT(0) ;
16114 return ;
16115 }
16116
16117 /* Dose not need to send notification to upper layer
16118 * Just free allocated resources */
16119 if( pWdaParams != NULL )
16120 {
16121 if( pWdaParams->wdaWdiApiMsgParam != NULL )
16122 {
16123 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16124 }
16125 vos_mem_free(pWdaParams->wdaMsgParam) ;
16126 vos_mem_free(pWdaParams) ;
16127 }
16128}
16129
16130/*
16131 * FUNCTION: WDA_ProcessSetTmLevelReq
16132 * Set TM Level request
16133 */
16134VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
16135 tAniSetTmLevelReq *setTmLevelReq)
16136{
16137 WDI_Status status = WDI_STATUS_SUCCESS ;
16138 tWDA_ReqParams *pWdaParams ;
16139 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
16140 (WDI_SetTmLevelReqType *)vos_mem_malloc(
16141 sizeof(WDI_SetTmLevelReqType)) ;
16142 if(NULL == wdiSetTmLevelReq)
16143 {
16144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16145 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16146 VOS_ASSERT(0);
16147 return VOS_STATUS_E_NOMEM;
16148 }
16149
16150 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16151 if(NULL == pWdaParams)
16152 {
16153 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16154 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16155 VOS_ASSERT(0);
16156 vos_mem_free(wdiSetTmLevelReq);
16157 return VOS_STATUS_E_NOMEM;
16158 }
16159
16160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16161 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16162
16163 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
16164 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
16165
16166 pWdaParams->pWdaContext = pWDA;
16167 pWdaParams->wdaMsgParam = setTmLevelReq;
16168 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
16169
16170 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
16171 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
16172
16173 if(IS_WDI_STATUS_FAILURE(status))
16174 {
16175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]16176 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16177 vos_mem_free(pWdaParams->wdaMsgParam) ;
16178 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16179 vos_mem_free(pWdaParams) ;
16180 }
16181
16182 return CONVERT_WDI2VOS_STATUS(status) ;
16183}
16184
16185VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
16186 tpTxControlParams pTxCtrlParam)
16187{
16188 VOS_STATUS wdaStatus;
16189
16190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16191 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16192 if( pTxCtrlParam == NULL )
16193 {
16194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16195 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16196 return VOS_STATUS_E_FAILURE;
16197 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16198 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
16199 {
16200 wdaStatus = WDA_SuspendDataTx(pWDA);
16201 }
16202 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
16203 {
16204 wdaStatus = WDA_ResumeDataTx(pWDA);
16205 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16206 return wdaStatus;
16207}
16208
16209 /* FUNCTION WDA_featureCapsExchange
16210 * WDA API to invoke capability exchange between host and FW.
16211 */
16212void WDA_featureCapsExchange(v_PVOID_t pVosContext)
16213{
16214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16215 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16216 WDI_featureCapsExchangeReq( NULL, pVosContext);
16217}
16218
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]16219/* FUNCTION WDA_disableCapablityFeature
16220 * WDA API to diable Active mode offload in host.
16221 */
16222void WDA_disableCapablityFeature(tANI_U8 feature_index)
16223{
16224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16225 "%s:enter", __func__ );
16226 WDI_disableCapablityFeature(feature_index);
16227}
16228
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16229 /* FUNCTION WDA_getHostWlanFeatCaps
16230 * Wrapper for WDI API, that will return if the feature (enum value).passed
16231 * to this API is supported or not in Host
16232 * return value
16233 * 0 - implies feature is NOT Supported
16234 * any non zero value - implies feature is SUPPORTED
16235 */
16236tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
16237{
16238 return WDI_getHostWlanFeatCaps(featEnumValue);
16239}
16240
16241 /* FUNCTION WDA_getFwWlanFeatCaps
16242 * Wrapper for WDI API, that will return if the feature (enum value).passed
16243 * to this API is supported or not in FW
16244 * return value
16245 * 0 - implies feature is NOT Supported
16246 * any non zero value - implies feature is SUPPORTED
16247 */
16248tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
16249{
16250 return WDI_getFwWlanFeatCaps(featEnumValue);
16251}
16252
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]16253
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16254/*
16255 * FUNCTION: WDA_shutdown
16256 * Shutdown WDA/WDI without handshaking with Riva.
16257 * Synchronous function.
16258 */
16259VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
16260{
16261 WDI_Status wdiStatus;
16262 //tANI_U8 eventIdx = 0;
16263 VOS_STATUS status = VOS_STATUS_SUCCESS;
16264 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16265 if (NULL == pWDA)
16266 {
16267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16268 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16269 VOS_ASSERT(0);
16270 return VOS_STATUS_E_FAILURE;
16271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16272 /* FTM mode stay START_STATE */
16273 if( (WDA_READY_STATE != pWDA->wdaState) &&
16274 (WDA_INIT_STATE != pWDA->wdaState) &&
16275 (WDA_START_STATE != pWDA->wdaState) )
16276 {
16277 VOS_ASSERT(0);
16278 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16279
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16280 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
16281 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16282 {
16283 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16284 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16285 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]16286 else
16287 {
16288 vos_event_destroy(&pWDA->ftmStopDoneEvent);
16289 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16290
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16291 /* call WDI shutdown */
16292 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16293 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
16294 {
16295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16296 "error in WDA Stop" );
16297 status = VOS_STATUS_E_FAILURE;
16298 }
16299 /* WDI stop is synchrnous, shutdown is complete when it returns */
16300 pWDA->wdaState = WDA_STOP_STATE;
16301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16302 /* shutdown should perform the stop & close actions. */
16303 /* Destroy the event */
16304 status = vos_event_destroy(&pWDA->txFrameEvent);
16305 if(!VOS_IS_STATUS_SUCCESS(status))
16306 {
16307 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16308 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16309 status = VOS_STATUS_E_FAILURE;
16310 }
16311 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
16312 if(!VOS_IS_STATUS_SUCCESS(status))
16313 {
16314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16315 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16316 status = VOS_STATUS_E_FAILURE;
16317 }
16318 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
16319 if(!VOS_IS_STATUS_SUCCESS(status))
16320 {
16321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16322 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16323 status = VOS_STATUS_E_FAILURE;
16324 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16325 /* free WDA context */
16326 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
16327 if ( !VOS_IS_STATUS_SUCCESS(status) )
16328 {
16329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16330 "error in WDA close " );
16331 status = VOS_STATUS_E_FAILURE;
16332 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16333 return status;
16334}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16335
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16336/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16337 * FUNCTION: WDA_setNeedShutdown
16338 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16339 */
16340
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16341void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16342{
16343 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16344 if(pWDA == NULL)
16345 {
16346 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16347 "Could not get the WDA Context pointer" );
16348 return;
16349 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16350 pWDA->needShutdown = TRUE;
16351}
16352/*
16353 * FUNCTION: WDA_needShutdown
16354 * WDA needs a shutdown
16355 */
16356
16357v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
16358{
16359 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16360 if(pWDA == NULL)
16361 {
16362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16363 "Could not get the WDA Context pointer" );
16364 return 0;
16365 }
16366 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16367}
16368
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16369#ifdef WLAN_FEATURE_11AC
16370/*
16371 * FUNCTION: WDA_SetBeaconFilterReqCallback
16372 *
16373 */
16374void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
16375{
16376 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16378 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16379 if(NULL == pWdaParams)
16380 {
16381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16382 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16383 VOS_ASSERT(0) ;
16384 return ;
16385 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16386
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16387 vos_mem_free(pWdaParams->wdaMsgParam) ;
16388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16389 vos_mem_free(pWdaParams) ;
16390 /*
16391 * No respone required for SetBeaconFilter req so just free the request
16392 * param here
16393 */
16394
16395 return ;
16396}
16397
16398VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
16399 tUpdateVHTOpMode *pData)
16400{
16401 WDI_Status status = WDI_STATUS_SUCCESS ;
16402 tWDA_ReqParams *pWdaParams ;
16403 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
16404 sizeof(WDI_UpdateVHTOpMode)) ;
16405 if(NULL == wdiTemp)
16406 {
16407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16408 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16409 VOS_ASSERT(0);
16410 return VOS_STATUS_E_NOMEM;
16411 }
16412 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16413 if(NULL == pWdaParams)
16414 {
16415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16416 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16417 VOS_ASSERT(0);
16418 vos_mem_free(wdiTemp);
16419 return VOS_STATUS_E_NOMEM;
16420 }
16421
16422 wdiTemp->opMode = pData->opMode;
16423 wdiTemp->staId = pData->staId;
16424
16425 pWdaParams->pWdaContext = pWDA;
16426 /* Store Req pointer, as this will be used for response */
16427 pWdaParams->wdaMsgParam = (void *)pData;
16428 /* store Params pass it to WDI */
16429 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16430
16431 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16432
16433 if(IS_WDI_STATUS_FAILURE(status))
16434 {
16435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16436 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16437 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16438 vos_mem_free(pWdaParams->wdaMsgParam);
16439 vos_mem_free(pWdaParams);
16440 }
16441 return CONVERT_WDI2VOS_STATUS(status) ;
16442}
16443#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16444
16445/*==========================================================================
16446 FUNCTION WDA_TransportChannelDebug
16447
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16448 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16449 Display Transport Channel debugging information
16450 User may request to display DXE channel snapshot
16451 Or if host driver detects any abnormal stcuk may display
16452
16453 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16454 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16455 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16456 debugFlags : Enable stall detect features
16457 defined by WPAL_DeviceDebugFlags
16458 These features may effect
16459 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16460
16461 RETURN VALUE
16462 NONE
16463
16464===========================================================================*/
16465void WDA_TransportChannelDebug
16466(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16467 tpAniSirGlobal pMac,
16468 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16469 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16470)
16471{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16472 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16473 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16474}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16475
16476/*==========================================================================
16477 FUNCTION WDA_SetEnableSSR
16478
16479 DESCRIPTION
16480 API to enable/disable SSR on WDI timeout
16481
16482 PARAMETERS
16483 enableSSR : enable/disable SSR
16484
16485 RETURN VALUE
16486 NONE
16487
16488===========================================================================*/
16489void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16490{
16491 WDI_SetEnableSSR(enableSSR);
16492}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16493
16494#ifdef FEATURE_WLAN_LPHB
16495/*
16496 * FUNCTION: WDA_LPHBconfRspCallback
16497 *
16498 */
16499void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16500{
16501 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16502
16503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16504 "<------ %s " ,__func__);
16505 if (NULL == pWdaParams)
16506 {
16507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16508 "%s: pWdaParams received NULL", __func__);
16509 VOS_ASSERT(0) ;
16510 return ;
16511 }
16512
16513 /* Do not need to send notification to upper layer
16514 * Just free allocated resources */
16515 if (pWdaParams != NULL)
16516 {
16517 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16518 {
16519 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16520 }
16521 vos_mem_free(pWdaParams->wdaMsgParam) ;
16522 vos_mem_free(pWdaParams) ;
16523 }
16524
16525 return;
16526}
16527
16528/*
16529 * FUNCTION: WDA_ProcessLPHBConfReq
16530 *
16531 */
16532VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16533 tSirLPHBReq *pData)
16534{
16535 WDI_Status wdiStatus;
16536 tWDA_ReqParams *pWdaParams ;
16537
16538 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16539 "------> %s " , __func__);
16540
16541 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16542 if (NULL == pWdaParams)
16543 {
16544 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16545 "%s: VOS MEM Alloc Failure", __func__);
16546 VOS_ASSERT(0);
16547 vos_mem_free(pData);
16548 return VOS_STATUS_E_NOMEM;
16549 }
16550
16551 pWdaParams->pWdaContext = pWDA;
16552 pWdaParams->wdaMsgParam = (void *)pData;
16553 pWdaParams->wdaWdiApiMsgParam = NULL;
16554
16555 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16556 if (WDI_STATUS_PENDING == wdiStatus)
16557 {
16558 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16559 "Pending received for %s:%d ", __func__, __LINE__);
16560 }
16561 else if (WDI_STATUS_SUCCESS != wdiStatus)
16562 {
16563 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16564 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16565 vos_mem_free(pWdaParams->wdaMsgParam);
16566 vos_mem_free(pWdaParams);
16567 }
16568
16569 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16570}
16571#endif /* FEATURE_WLAN_LPHB */
16572
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16573void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16574 void* pUserData)
16575{
16576 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16577
16578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16579 "<------ %s " ,__func__);
16580 if (NULL == pBcnMissRateInfo)
16581 {
16582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16583 "%s: pWdaParams received NULL", __func__);
16584 VOS_ASSERT(0) ;
16585 return ;
16586 }
16587 if (pBcnMissRateInfo->callback)
16588 {
16589 pBcnMissRateInfo->callback(status, bcnMissRate,
16590 pBcnMissRateInfo->data);
16591 }
16592 vos_mem_free(pUserData);
16593
16594 return;
16595}
16596
16597v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16598 tSirBcnMissRateReq *pData)
16599{
16600 WDI_Status wdiStatus;
16601 tSirBcnMissRateInfo *pBcnMissRateInfo;
16602
16603 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16604 "------> %s " , __func__);
16605
16606 pBcnMissRateInfo =
16607 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16608 if (NULL == pBcnMissRateInfo)
16609 {
16610 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16611 "%s: VOS MEM Alloc Failure", __func__);
16612 VOS_ASSERT(0);
16613 vos_mem_free(pData);
16614 return;
16615 }
16616
16617 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16618 pBcnMissRateInfo->data = pData->data;
16619
16620 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16621 WDA_GetBcnMissRateCallback,
16622 pData->bssid);
16623 if (WDI_STATUS_PENDING == wdiStatus)
16624 {
16625 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16626 "Pending received for %s:%d ", __func__, __LINE__);
16627 }
16628 else if (WDI_STATUS_SUCCESS != wdiStatus)
16629 {
16630 if (pBcnMissRateInfo->callback)
16631 {
16632 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16633 -1, pBcnMissRateInfo->data);
16634 }
16635 }
16636 vos_mem_free(pData);
16637}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16638
16639#ifdef WLAN_FEATURE_EXTSCAN
16640
16641/*==========================================================================
16642 FUNCTION WDA_EXTScanStartRspCallback
16643
16644 DESCRIPTION
16645 API to send EXTScan Start Response to HDD
16646
16647 PARAMETERS
16648 pEventData: Response from FW
16649 pUserData:
16650===========================================================================*/
16651void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16652{
16653 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16654 tWDA_CbContext *pWDA = NULL;
16655 void *pCallbackContext;
16656 tpAniSirGlobal pMac;
16657
16658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16659 "%s:", __func__);
16660 if (NULL == pWdaParams)
16661 {
16662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16663 "%s: pWdaParams received NULL", __func__);
16664 VOS_ASSERT(0);
16665 return;
16666 }
16667
16668 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16669
16670 if (NULL == pWDA)
16671 {
16672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16673 "%s: pWDA received NULL", __func__);
16674 VOS_ASSERT(0);
16675 goto error;
16676 }
16677
16678 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16679 if (NULL == pMac)
16680 {
16681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16682 "%s:pMac is NULL", __func__);
16683 VOS_ASSERT(0);
16684 goto error;
16685 }
16686
16687 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16688
16689 if (pMac->sme.pEXTScanIndCb)
16690 {
16691 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16692 pEventData);
16693 }
16694 else
16695 {
16696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16697 "%s:HDD callback is null", __func__);
16698 VOS_ASSERT(0);
16699 }
16700
16701error:
16702
16703 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16704 {
16705 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16706 }
16707 if (pWdaParams->wdaMsgParam != NULL)
16708 {
16709 vos_mem_free(pWdaParams->wdaMsgParam);
16710 }
16711 vos_mem_free(pWdaParams) ;
16712
16713 return;
16714}
16715
16716/*==========================================================================
16717 FUNCTION WDA_EXTScanStopRspCallback
16718
16719 DESCRIPTION
16720 API to send EXTScan Stop Response to HDD
16721
16722 PARAMETERS
16723 pEventData: Response from FW
16724 pUserData:
16725===========================================================================*/
16726void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16727{
16728 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16729 tWDA_CbContext *pWDA = NULL;
16730 void *pCallbackContext;
16731 tpAniSirGlobal pMac;
16732
16733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16734 "%s:", __func__);
16735 if (NULL == pWdaParams)
16736 {
16737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16738 "%s: pWdaParams received NULL", __func__);
16739 VOS_ASSERT(0);
16740 return;
16741 }
16742
16743 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16744
16745 if (NULL == pWDA)
16746 {
16747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16748 "%s: pWDA received NULL", __func__);
16749 VOS_ASSERT(0);
16750 goto error;
16751 }
16752
16753 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16754 if (NULL == pMac)
16755 {
16756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16757 "%s:pMac is NULL", __func__);
16758 VOS_ASSERT(0);
16759 goto error;
16760 }
16761 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16762
16763 if (pMac->sme.pEXTScanIndCb)
16764 {
16765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16766 "%s:HDD call back function called", __func__);
16767 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16768 pEventData);
16769 }
16770 else
16771 {
16772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16773 "%s:HDD callback is null", __func__);
16774 VOS_ASSERT(0);
16775 }
16776
16777error:
16778
16779 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16780 {
16781 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16782 }
16783 if (pWdaParams->wdaMsgParam != NULL)
16784 {
16785 vos_mem_free(pWdaParams->wdaMsgParam);
16786 }
16787 vos_mem_free(pWdaParams) ;
16788
16789
16790 return;
16791}
16792
16793/*==========================================================================
16794 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16795
16796 DESCRIPTION
16797 API to send EXTScan Get Cached Results Response to HDD
16798
16799 PARAMETERS
16800 pEventData: Response from FW
16801 pUserData:
16802===========================================================================*/
16803void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16804{
16805 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16806 tWDA_CbContext *pWDA = NULL;
16807 void *pCallbackContext;
16808 tpAniSirGlobal pMac;
16809
16810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16811 "%s: ", __func__);
16812 if (NULL == pWdaParams)
16813 {
16814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16815 "%s: pWdaParams received NULL", __func__);
16816 VOS_ASSERT(0);
16817 return;
16818 }
16819
16820 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16821
16822 if (NULL == pWDA)
16823 {
16824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16825 "%s: pWDA received NULL", __func__);
16826 VOS_ASSERT(0);
16827 goto error;
16828 }
16829
16830 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16831 if (NULL == pMac)
16832 {
16833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16834 "%s:pMac is NULL", __func__);
16835 VOS_ASSERT(0);
16836 goto error;
16837 }
16838
16839 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16840
16841 if (pMac->sme.pEXTScanIndCb)
16842 {
16843 pMac->sme.pEXTScanIndCb(pCallbackContext,
16844 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16845 pEventData);
16846 }
16847 else
16848 {
16849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16850 "%s:HDD callback is null", __func__);
16851 VOS_ASSERT(0);
16852 }
16853
16854
16855error:
16856
16857 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16858 {
16859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16860 }
16861 if (pWdaParams->wdaMsgParam != NULL)
16862 {
16863 vos_mem_free(pWdaParams->wdaMsgParam);
16864 }
16865 vos_mem_free(pWdaParams) ;
16866
16867 return;
16868}
16869
16870/*==========================================================================
16871 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16872
16873 DESCRIPTION
16874 API to send EXTScan Get Capabilities Response to HDD
16875
16876 PARAMETERS
16877 pEventData: Response from FW
16878 pUserData:
16879===========================================================================*/
16880void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16881{
16882 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16883 tWDA_CbContext *pWDA = NULL;
16884 void *pCallbackContext;
16885 tpAniSirGlobal pMac;
16886
16887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16888 "%s:", __func__);
16889 if (NULL == pWdaParams)
16890 {
16891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16892 "%s: pWdaParams received NULL", __func__);
16893 VOS_ASSERT(0);
16894 return;
16895 }
16896
16897 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16898
16899 if (NULL == pWDA)
16900 {
16901 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16902 "%s: pWDA received NULL", __func__);
16903 VOS_ASSERT(0);
16904 goto error;
16905 }
16906
16907 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16908 if (NULL == pMac)
16909 {
16910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16911 "%s:pMac is NULL", __func__);
16912 VOS_ASSERT(0);
16913 goto error;
16914 }
16915
16916 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16917
16918 if (pMac->sme.pEXTScanIndCb)
16919 {
16920 pMac->sme.pEXTScanIndCb(pCallbackContext,
16921 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16922 pEventData);
16923 }
16924 else
16925 {
16926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16927 "%s:HDD callback is null", __func__);
16928 VOS_ASSERT(0);
16929 }
16930
16931
16932error:
16933
16934 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16935 {
16936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16937 }
16938 if (pWdaParams->wdaMsgParam != NULL)
16939 {
16940 vos_mem_free(pWdaParams->wdaMsgParam);
16941 }
16942 vos_mem_free(pWdaParams) ;
16943
16944 return;
16945}
16946
16947/*==========================================================================
16948 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16949
16950 DESCRIPTION
16951 API to send EXTScan Set BSSID Hotlist Response to HDD
16952
16953 PARAMETERS
16954 pEventData: Response from FW
16955 pUserData:
16956===========================================================================*/
16957void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16958{
16959 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16960 tWDA_CbContext *pWDA = NULL;
16961 void *pCallbackContext;
16962 tpAniSirGlobal pMac;
16963
16964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16965 "%s: ", __func__);
16966 if (NULL == pWdaParams)
16967 {
16968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16969 "%s: pWdaParams received NULL", __func__);
16970 VOS_ASSERT(0) ;
16971 return;
16972 }
16973
16974 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16975
16976 if (NULL == pWDA)
16977 {
16978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16979 "%s: pWDA received NULL", __func__);
16980 VOS_ASSERT(0);
16981 goto error;
16982 }
16983
16984 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16985 if (NULL == pMac)
16986 {
16987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16988 "%s:pMac is NULL", __func__);
16989 VOS_ASSERT(0);
16990 goto error;
16991 }
16992
16993 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16994
16995 if (pMac->sme.pEXTScanIndCb)
16996 {
16997 pMac->sme.pEXTScanIndCb(pCallbackContext,
16998 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16999 pEventData);
17000 }
17001 else
17002 {
17003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17004 "%s:HDD callback is null", __func__);
17005 VOS_ASSERT(0);
17006 }
17007
17008
17009error:
17010
17011 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17012 {
17013 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17014 }
17015 if (pWdaParams->wdaMsgParam != NULL)
17016 {
17017 vos_mem_free(pWdaParams->wdaMsgParam);
17018 }
17019 vos_mem_free(pWdaParams) ;
17020
17021 return;
17022}
17023
17024/*==========================================================================
17025 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
17026
17027 DESCRIPTION
17028 API to send EXTScan ReSet BSSID Hotlist Response to HDD
17029
17030 PARAMETERS
17031 pEventData: Response from FW
17032 pUserData:
17033===========================================================================*/
17034void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
17035{
17036 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17037 tWDA_CbContext *pWDA = NULL;
17038 void *pCallbackContext;
17039 tpAniSirGlobal pMac;
17040
17041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17042 "%s:", __func__);
17043 if (NULL == pWdaParams)
17044 {
17045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17046 "%s: pWdaParams received NULL", __func__);
17047 VOS_ASSERT(0) ;
17048 return;
17049 }
17050
17051 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17052
17053 if (NULL == pWDA)
17054 {
17055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17056 "%s: pWDA received NULL", __func__);
17057 VOS_ASSERT(0);
17058 goto error;
17059 }
17060
17061 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17062 if (NULL == pMac)
17063 {
17064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17065 "%s:pMac is NULL", __func__);
17066 VOS_ASSERT(0);
17067 goto error;
17068 }
17069
17070 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17071
17072 if (pMac->sme.pEXTScanIndCb)
17073 {
17074 pMac->sme.pEXTScanIndCb(pCallbackContext,
17075 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
17076 pEventData);
17077 }
17078 else
17079 {
17080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17081 "%s:HDD callback is null", __func__);
17082 VOS_ASSERT(0);
17083 }
17084
17085
17086error:
17087
17088 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17089 {
17090 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17091 }
17092 if (pWdaParams->wdaMsgParam != NULL)
17093 {
17094 vos_mem_free(pWdaParams->wdaMsgParam);
17095 }
17096 vos_mem_free(pWdaParams) ;
17097
17098 return;
17099}
17100
17101/*==========================================================================
17102 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
17103
17104 DESCRIPTION
17105 API to send EXTScan Set Significant RSSI Change RSP to HDD
17106
17107 PARAMETERS
17108 pEventData: Response from FW
17109 pUserData:
17110===========================================================================*/
17111void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
17112{
17113 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17114 tWDA_CbContext *pWDA = NULL;
17115 void *pCallbackContext;
17116 tpAniSirGlobal pMac;
17117
17118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17119 "%s:", __func__);
17120 if (NULL == pWdaParams)
17121 {
17122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17123 "%s: pWdaParams received NULL", __func__);
17124 VOS_ASSERT(0) ;
17125 return;
17126 }
17127
17128 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17129
17130 if (NULL == pWDA)
17131 {
17132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17133 "%s: pWDA received NULL", __func__);
17134 VOS_ASSERT(0);
17135 goto error;
17136 }
17137
17138 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17139 if (NULL == pMac)
17140 {
17141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17142 "%s:pMac is NULL", __func__);
17143 VOS_ASSERT(0);
17144 goto error;
17145 }
17146
17147 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17148
17149 if (pMac->sme.pEXTScanIndCb)
17150 {
17151 pMac->sme.pEXTScanIndCb(pCallbackContext,
17152 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
17153 pEventData);
17154 }
17155 else
17156 {
17157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17158 "%s:HDD callback is null", __func__);
17159 VOS_ASSERT(0);
17160 }
17161
17162
17163error:
17164
17165 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17166 {
17167 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17168 }
17169 if (pWdaParams->wdaMsgParam != NULL)
17170 {
17171 vos_mem_free(pWdaParams->wdaMsgParam);
17172 }
17173 vos_mem_free(pWdaParams) ;
17174
17175 return;
17176}
17177
17178/*==========================================================================
17179 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
17180
17181 DESCRIPTION
17182 API to send EXTScan Set Significant RSSI Change RSP to HDD
17183
17184 PARAMETERS
17185 pEventData: Response from FW
17186 pUserData:
17187===========================================================================*/
17188void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
17189 void* pUserData)
17190{
17191 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17192 tWDA_CbContext *pWDA = NULL;
17193 void *pCallbackContext;
17194 tpAniSirGlobal pMac;
17195
17196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17197 "%s:", __func__);
17198 if (NULL == pWdaParams)
17199 {
17200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17201 "%s: pWdaParams received NULL", __func__);
17202 VOS_ASSERT(0) ;
17203 return;
17204 }
17205
17206 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17207
17208 if (NULL == pWDA)
17209 {
17210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17211 "%s: pWDA received NULL", __func__);
17212 VOS_ASSERT(0);
17213 goto error;
17214 }
17215
17216 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17217 if (NULL == pMac)
17218 {
17219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17220 "%s:pMac is NULL", __func__);
17221 VOS_ASSERT(0);
17222 goto error;
17223 }
17224
17225 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17226
17227 if (pMac->sme.pEXTScanIndCb)
17228 {
17229 pMac->sme.pEXTScanIndCb(pCallbackContext,
17230 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
17231 pEventData);
17232 }
17233 else
17234 {
17235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17236 "%s:HDD callback is null", __func__);
17237 VOS_ASSERT(0);
17238 }
17239
17240
17241error:
17242
17243 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17244 {
17245 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17246 }
17247 if (pWdaParams->wdaMsgParam != NULL)
17248 {
17249 vos_mem_free(pWdaParams->wdaMsgParam);
17250 }
17251 vos_mem_free(pWdaParams) ;
17252
17253 return;
17254}
17255
17256/*==========================================================================
17257 FUNCTION WDA_ProcessEXTScanStartReq
17258
17259 DESCRIPTION
17260 API to send EXTScan Start Request to WDI
17261
17262 PARAMETERS
17263 pWDA: Pointer to WDA context
17264 wdaRequest: Pointer to EXTScan req parameters
17265===========================================================================*/
17266VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
17267 tSirEXTScanStartReqParams *wdaRequest)
17268{
17269 WDI_Status status = WDI_STATUS_SUCCESS;
17270 tWDA_ReqParams *pWdaParams;
17271
17272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17273 "%s: ", __func__);
17274 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17275 if (NULL == pWdaParams)
17276 {
17277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17278 "%s: VOS MEM Alloc Failure", __func__);
17279 VOS_ASSERT(0);
17280 return VOS_STATUS_E_NOMEM;
17281 }
17282 pWdaParams->pWdaContext = pWDA;
17283 pWdaParams->wdaMsgParam = wdaRequest;
17284 pWdaParams->wdaWdiApiMsgParam = NULL;
17285
17286 status = WDI_EXTScanStartReq((void *)wdaRequest,
17287 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
17288 (void *)pWdaParams);
17289 if (IS_WDI_STATUS_FAILURE(status))
17290 {
17291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17292 "Failure to request. Free all the memory " );
17293 vos_mem_free(pWdaParams->wdaMsgParam);
17294 vos_mem_free(pWdaParams);
17295 }
17296 return CONVERT_WDI2VOS_STATUS(status);
17297}
17298
17299/*==========================================================================
17300 FUNCTION WDA_ProcessEXTScanStopReq
17301
17302 DESCRIPTION
17303 API to send EXTScan Start Request to WDI
17304
17305 PARAMETERS
17306 pWDA: Pointer to WDA context
17307 wdaRequest: Pointer to EXTScan req parameters
17308===========================================================================*/
17309VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
17310 tSirEXTScanStopReqParams *wdaRequest)
17311{
17312 WDI_Status status = WDI_STATUS_SUCCESS;
17313 tWDA_ReqParams *pWdaParams;
17314
17315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17316 "%s:", __func__);
17317 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17318 if (NULL == pWdaParams)
17319 {
17320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17321 "%s: VOS MEM Alloc Failure", __func__);
17322 VOS_ASSERT(0);
17323 return VOS_STATUS_E_NOMEM;
17324 }
17325 pWdaParams->pWdaContext = pWDA;
17326 pWdaParams->wdaMsgParam = wdaRequest;
17327 pWdaParams->wdaWdiApiMsgParam = NULL;
17328
17329 status = WDI_EXTScanStopReq((void *)wdaRequest,
17330 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
17331 (void *)pWdaParams);
17332 if (IS_WDI_STATUS_FAILURE(status))
17333 {
17334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17335 "Failure to request. Free all the memory " );
17336 vos_mem_free(pWdaParams->wdaMsgParam);
17337 vos_mem_free(pWdaParams);
17338 }
17339 return CONVERT_WDI2VOS_STATUS(status);
17340}
17341
17342/*==========================================================================
17343 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
17344
17345 DESCRIPTION
17346 API to send EXTScan Get Cached Results Request to WDI
17347
17348 PARAMETERS
17349 pWDA: Pointer to WDA context
17350 wdaRequest: Pointer to EXTScan req parameters
17351===========================================================================*/
17352VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
17353 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
17354{
17355 WDI_Status status = WDI_STATUS_SUCCESS;
17356 tWDA_ReqParams *pWdaParams;
17357
17358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17359 "%s: ", __func__);
17360 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17361 if (NULL == pWdaParams)
17362 {
17363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17364 "%s: VOS MEM Alloc Failure", __func__);
17365 VOS_ASSERT(0);
17366 return VOS_STATUS_E_NOMEM;
17367 }
17368 pWdaParams->pWdaContext = pWDA;
17369 pWdaParams->wdaMsgParam = wdaRequest;
17370 pWdaParams->wdaWdiApiMsgParam = NULL;
17371
17372 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
17373 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
17374 (void *)pWdaParams);
17375 if (IS_WDI_STATUS_FAILURE(status))
17376 {
17377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17378 "Failure to request. Free all the memory " );
17379 vos_mem_free(pWdaParams->wdaMsgParam);
17380 vos_mem_free(pWdaParams);
17381 }
17382 return CONVERT_WDI2VOS_STATUS(status);
17383}
17384
17385/*==========================================================================
17386 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
17387
17388 DESCRIPTION
17389 API to send EXTScan Get Capabilities Request to WDI
17390
17391 PARAMETERS
17392 pWDA: Pointer to WDA context
17393 wdaRequest: Pointer to EXTScan req parameters
17394===========================================================================*/
17395VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
17396 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
17397{
17398 WDI_Status status = WDI_STATUS_SUCCESS;
17399 tWDA_ReqParams *pWdaParams;
17400
17401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17402 "%s:", __func__);
17403 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17404 if (NULL == pWdaParams)
17405 {
17406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17407 "%s: VOS MEM Alloc Failure", __func__);
17408 VOS_ASSERT(0);
17409 return VOS_STATUS_E_NOMEM;
17410 }
17411 pWdaParams->pWdaContext = pWDA;
17412 pWdaParams->wdaMsgParam = wdaRequest;
17413 pWdaParams->wdaWdiApiMsgParam = NULL;
17414
17415 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17416 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17417 (void *)pWdaParams);
17418 if (IS_WDI_STATUS_FAILURE(status))
17419 {
17420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17421 "Failure to request. Free all the memory " );
17422 vos_mem_free(pWdaParams->wdaMsgParam);
17423 vos_mem_free(pWdaParams);
17424 }
17425 return CONVERT_WDI2VOS_STATUS(status);
17426}
17427
17428/*==========================================================================
17429 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17430
17431 DESCRIPTION
17432 API to send Set BSSID Hotlist Request to WDI
17433
17434 PARAMETERS
17435 pWDA: Pointer to WDA context
17436 wdaRequest: Pointer to EXTScan req parameters
17437===========================================================================*/
17438VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17439 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17440{
17441 WDI_Status status = WDI_STATUS_SUCCESS;
17442 tWDA_ReqParams *pWdaParams;
17443
17444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17445 "%s: ", __func__);
17446 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17447 if (NULL == pWdaParams)
17448 {
17449 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17450 "%s: VOS MEM Alloc Failure", __func__);
17451 VOS_ASSERT(0);
17452 return VOS_STATUS_E_NOMEM;
17453 }
17454 pWdaParams->pWdaContext = pWDA;
17455 pWdaParams->wdaMsgParam = wdaRequest;
17456 pWdaParams->wdaWdiApiMsgParam = NULL;
17457
17458 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17459 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17460 (void *)pWdaParams);
17461 if (IS_WDI_STATUS_FAILURE(status))
17462 {
17463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17464 "Failure to request. Free all the memory " );
17465 vos_mem_free(pWdaParams->wdaMsgParam);
17466 vos_mem_free(pWdaParams);
17467 }
17468 return CONVERT_WDI2VOS_STATUS(status);
17469}
17470
17471/*==========================================================================
17472 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17473
17474 DESCRIPTION
17475 API to send Reset BSSID Hotlist Request to WDI
17476
17477 PARAMETERS
17478 pWDA: Pointer to WDA context
17479 wdaRequest: Pointer to EXTScan req parameters
17480===========================================================================*/
17481VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17482 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17483{
17484 WDI_Status status = WDI_STATUS_SUCCESS;
17485 tWDA_ReqParams *pWdaParams;
17486
17487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17488 "%s:", __func__);
17489 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17490 if (NULL == pWdaParams)
17491 {
17492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17493 "%s: VOS MEM Alloc Failure", __func__);
17494 VOS_ASSERT(0);
17495 return VOS_STATUS_E_NOMEM;
17496 }
17497 pWdaParams->pWdaContext = pWDA;
17498 pWdaParams->wdaMsgParam = wdaRequest;
17499 pWdaParams->wdaWdiApiMsgParam = NULL;
17500
17501 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17502 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17503 (void *)pWdaParams);
17504 if (IS_WDI_STATUS_FAILURE(status))
17505 {
17506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17507 "Failure to request. Free all the memory " );
17508 vos_mem_free(pWdaParams->wdaMsgParam);
17509 vos_mem_free(pWdaParams);
17510 }
17511 return CONVERT_WDI2VOS_STATUS(status);
17512}
17513
17514/*==========================================================================
17515 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17516
17517 DESCRIPTION
17518 API to send Set Significant RSSI Change Request to WDI
17519
17520 PARAMETERS
17521 pWDA: Pointer to WDA context
17522 wdaRequest: Pointer to EXTScan req parameters
17523===========================================================================*/
17524VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17525 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17526{
17527 WDI_Status status = WDI_STATUS_SUCCESS;
17528 tWDA_ReqParams *pWdaParams;
17529
17530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17531 "%s: ", __func__);
17532 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17533 if (NULL == pWdaParams)
17534 {
17535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17536 "%s: VOS MEM Alloc Failure", __func__);
17537 VOS_ASSERT(0);
17538 return VOS_STATUS_E_NOMEM;
17539 }
17540 pWdaParams->pWdaContext = pWDA;
17541 pWdaParams->wdaMsgParam = wdaRequest;
17542 pWdaParams->wdaWdiApiMsgParam = NULL;
17543
17544 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17545 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17546 (void *)pWdaParams);
17547 if (IS_WDI_STATUS_FAILURE(status))
17548 {
17549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17550 "Failure to request. Free all the memory " );
17551 vos_mem_free(pWdaParams->wdaMsgParam);
17552 vos_mem_free(pWdaParams);
17553 }
17554 return CONVERT_WDI2VOS_STATUS(status);
17555}
17556
17557/*==========================================================================
17558 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17559
17560 DESCRIPTION
17561 API to send Reset Significant RSSI Change Request to WDI
17562
17563 PARAMETERS
17564 pWDA: Pointer to WDA context
17565 wdaRequest: Pointer to EXTScan req parameters
17566===========================================================================*/
17567VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17568 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17569{
17570 WDI_Status status = WDI_STATUS_SUCCESS;
17571 tWDA_ReqParams *pWdaParams;
17572
17573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17574 "%s:", __func__);
17575 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17576 if (NULL == pWdaParams)
17577 {
17578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17579 "%s: VOS MEM Alloc Failure", __func__);
17580 VOS_ASSERT(0);
17581 return VOS_STATUS_E_NOMEM;
17582 }
17583 pWdaParams->pWdaContext = pWDA;
17584 pWdaParams->wdaMsgParam = wdaRequest;
17585 pWdaParams->wdaWdiApiMsgParam = NULL;
17586
17587 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17588 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17589 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17590 (void *)pWdaParams);
17591 if (IS_WDI_STATUS_FAILURE(status))
17592 {
17593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17594 "Failure to request. Free all the memory " );
17595 vos_mem_free(pWdaParams->wdaMsgParam);
17596 vos_mem_free(pWdaParams);
17597 }
17598 return CONVERT_WDI2VOS_STATUS(status);
17599}
17600#endif /* WLAN_FEATURE_EXTSCAN */
17601
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17602#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17603
17604/*==========================================================================
17605 FUNCTION WDA_LLStatsSetRspCallback
17606
17607 DESCRIPTION
17608 API to process set link layer statistics response from FW
17609
17610 PARAMETERS
17611 pRsp: Pointer to set link layer statistics response
17612 pUserData: Pointer to user data
17613
17614 RETURN VALUE
17615 NONE
17616
17617===========================================================================*/
17618void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17619{
17620 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17621
17622
17623 if (NULL == pWdaParams)
17624 {
17625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17626 "%s: pWdaParams received NULL", __func__);
17627 VOS_ASSERT(0) ;
17628 return ;
17629 }
17630
17631 /* Do not need to send notification to upper layer
17632 * Just free allocated resources */
17633 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17634 {
17635 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17636 }
17637 if (pWdaParams->wdaMsgParam != NULL)
17638 {
17639 vos_mem_free(pWdaParams->wdaMsgParam);
17640 }
17641 vos_mem_free(pWdaParams) ;
17642
17643 return;
17644}
17645
17646/*==========================================================================
17647 FUNCTION WDA_ProcessLLStatsSetReq
17648
17649 DESCRIPTION
17650 API to send Set Link Layer Stats request to WDI
17651
17652 PARAMETERS
17653 pWDA: Pointer to WDA context
17654 wdaRequest: Pointer to set Link Layer Stats req parameters
17655===========================================================================*/
17656VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17657 tSirLLStatsSetReq *wdaRequest)
17658{
17659 WDI_Status status = WDI_STATUS_SUCCESS;
17660 tWDA_ReqParams *pWdaParams;
17661
17662 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17663 if (NULL == pWdaParams)
17664 {
17665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17666 "%s: VOS MEM Alloc Failure", __func__);
17667 VOS_ASSERT(0);
17668 return VOS_STATUS_E_NOMEM;
17669 }
17670 pWdaParams->pWdaContext = pWDA;
17671 pWdaParams->wdaMsgParam = wdaRequest;
17672 pWdaParams->wdaWdiApiMsgParam = NULL;
17673
17674 status = WDI_LLStatsSetReq((void *)wdaRequest,
17675 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17676 (void *)pWdaParams);
17677 if (IS_WDI_STATUS_FAILURE(status))
17678 {
17679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17680 "Failure to request. Free all the memory " );
17681 vos_mem_free(pWdaParams->wdaMsgParam);
17682 vos_mem_free(pWdaParams);
17683 }
17684 return CONVERT_WDI2VOS_STATUS(status);
17685}
17686
17687/*==========================================================================
17688 FUNCTION WDA_LLStatsGetRspCallback
17689
17690 DESCRIPTION
17691 API to process get link layer statistics response from FW
17692
17693 PARAMETERS
17694 pRsp: Pointer to get link layer statistics response
17695 pUserData: Pointer to user data
17696
17697 RETURN VALUE
17698 NONE
17699
17700===========================================================================*/
17701void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17702{
17703 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17704
17705 if (NULL == pWdaParams)
17706 {
17707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17708 "%s: pWdaParams received NULL", __func__);
17709 VOS_ASSERT(0) ;
17710 return ;
17711 }
17712
17713 /* Do not need to send notification to upper layer
17714 * Just free allocated resources */
17715 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17716 {
17717 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17718 }
17719 if (pWdaParams->wdaMsgParam != NULL)
17720 {
17721 vos_mem_free(pWdaParams->wdaMsgParam);
17722 }
17723 vos_mem_free(pWdaParams) ;
17724
17725 return;
17726}
17727
17728/*==========================================================================
17729 FUNCTION WDA_ProcessLLStatsGetReq
17730
17731 DESCRIPTION
17732 API to send Get Link Layer Stats request to WDI
17733
17734 PARAMETERS
17735 pWDA: Pointer to WDA context
17736 wdaRequest: Pointer to get Link Layer Stats req parameters
17737===========================================================================*/
17738VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17739 tSirLLStatsGetReq *wdaRequest)
17740{
17741 WDI_Status status = WDI_STATUS_SUCCESS;
17742 tWDA_ReqParams *pWdaParams;
17743
17744 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17745 if (NULL == pWdaParams)
17746 {
17747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17748 "%s: VOS MEM Alloc Failure", __func__);
17749 VOS_ASSERT(0);
17750 return VOS_STATUS_E_NOMEM;
17751 }
17752 pWdaParams->pWdaContext = pWDA;
17753 pWdaParams->wdaMsgParam = wdaRequest;
17754 pWdaParams->wdaWdiApiMsgParam = NULL;
17755
17756 status = WDI_LLStatsGetReq((void *) wdaRequest,
17757 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17758 (void *)pWdaParams);
17759 if (IS_WDI_STATUS_FAILURE(status))
17760 {
17761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17762 "Failure to request. Free all the memory " );
17763 vos_mem_free(pWdaParams->wdaMsgParam);
17764 vos_mem_free(pWdaParams);
17765 }
17766 return CONVERT_WDI2VOS_STATUS(status);
17767}
17768
17769/*==========================================================================
17770 FUNCTION WDA_LLStatsClearRspCallback
17771
17772 DESCRIPTION
17773 API to process clear link layer statistics response from FW
17774
17775 PARAMETERS
17776 pRsp: Pointer to clear link layer statistics response
17777 pUserData: Pointer to user data
17778
17779 RETURN VALUE
17780 NONE
17781
17782===========================================================================*/
17783void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17784{
17785 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17786
17787
17788 if (NULL == pWdaParams)
17789 {
17790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17791 "%s: pWdaParams received NULL", __func__);
17792 VOS_ASSERT(0) ;
17793 return ;
17794 }
17795 /* Do not need to send notification to upper layer
17796 * Just free allocated resources */
17797 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17798 {
17799 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17800 }
17801 if (pWdaParams->wdaMsgParam != NULL)
17802 {
17803 vos_mem_free(pWdaParams->wdaMsgParam);
17804 }
17805 vos_mem_free(pWdaParams) ;
17806 return;
17807}
17808
17809/*==========================================================================
17810 FUNCTION WDA_ProcessLLStatsClearReq
17811
17812 DESCRIPTION
17813 API to send Clear Link Layer Stats request to WDI
17814
17815 PARAMETERS
17816 pWDA: Pointer to WDA context
17817 wdaRequest: Pointer to earLink Layer Stats req
17818===========================================================================*/
17819VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17820 tSirLLStatsClearReq *wdaRequest)
17821{
17822 WDI_Status status = WDI_STATUS_SUCCESS;
17823 tWDA_ReqParams *pWdaParams;
17824
17825 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17826 if (NULL == pWdaParams)
17827 {
17828 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17829 "%s: VOS MEM Alloc Failure", __func__);
17830 VOS_ASSERT(0);
17831 return VOS_STATUS_E_NOMEM;
17832 }
17833 pWdaParams->pWdaContext = pWDA;
17834 pWdaParams->wdaMsgParam = wdaRequest;
17835 pWdaParams->wdaWdiApiMsgParam = NULL;
17836
17837 status = WDI_LLStatsClearReq((void *) wdaRequest,
17838 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17839 (void *)pWdaParams);
17840 if (IS_WDI_STATUS_FAILURE(status))
17841 {
17842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17843 "Failure to request. Free all the memory " );
17844 vos_mem_free(pWdaParams->wdaMsgParam);
17845 vos_mem_free(pWdaParams);
17846 }
17847 return CONVERT_WDI2VOS_STATUS(status);
17848}
17849
17850#endif /* WLAN_FEATURE_LINK_LAYER_STATS */