Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 53677465ce5ba521e4e6fc96cc0920a5d84c300e / . / CORE / WDA / src / wlan_qct_wda.c
blob: 304eefc69a36213c5a2cd2c80d9da968556e867e [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) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2037 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2038#ifdef WLAN_DEBUG
2039 {
2040 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2041 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2042 "****** Dumping CFG TLV ***** ");
2043 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2044 {
2045 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2046 "%02x %02x %02x %02x %02x %02x %02x %02x",
2047 tlvStructStart[i],
2048 tlvStructStart[i+1],
2049 tlvStructStart[i+2],
2050 tlvStructStart[i+3],
2051 tlvStructStart[i+4],
2052 tlvStructStart[i+5],
2053 tlvStructStart[i+6],
2054 tlvStructStart[i+7]);
2055 }
2056 /* Dump the bytes in the last line*/
2057 for (; i < wdiStartParams->usConfigBufferLen; i++)
2058 {
2059 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2060 "%02x ",tlvStructStart[i]);
2061 }
2062 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2063 "**************************** ");
2064 }
2065#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2066 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2067handle_failure:
2068 vos_mem_free(configParam);
2069 return VOS_STATUS_E_FAILURE;
2070}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2071/*
2072 * FUNCTION: WDA_wdiCompleteCB
2073 * call the voss call back function
2074 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2075void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2076{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2077 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2078 tWDA_CbContext *wdaContext;
2079
2080 if(NULL == pWdaParams)
2081 {
2082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2083 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2084 VOS_ASSERT(0) ;
2085 return ;
2086 }
2087
2088 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2089
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2090 if (NULL == wdaContext)
2091 {
2092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2093 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2094 return ;
2095 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2096
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2097 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2098 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2099 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2100 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2101 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2102 vos_mem_free(pWdaParams);
2103
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2104 if(WDI_STATUS_SUCCESS != status)
2105 {
2106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2107 "WDI stop callback returned failure" );
2108 VOS_ASSERT(0) ;
2109 }
2110 else
2111 {
2112 wdaContext->wdaState = WDA_STOP_STATE;
2113 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2114
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2115 /* FTM Driver stop procedure should be synced.
2116 * Stop and Close will happen on same context */
2117 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2118 {
2119 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2120 {
2121 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2122 "%s: FTM Stop Event Set Fail", __func__);
2123 VOS_ASSERT(0);
2124 }
2125 }
2126
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2127 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2128 vos_WDAComplete_cback(wdaContext->pVosContext);
2129
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2130 return ;
2131}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2132/*
2133 * FUNCTION: WDA_stop
2134 * call WDI_stop
2135 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2136VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2137{
2138 WDI_Status wdiStatus;
2139 VOS_STATUS status = VOS_STATUS_SUCCESS;
2140 WDI_StopReqParamsType *wdiStopReq;
2141 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2142 tWDA_ReqParams *pWdaParams ;
2143
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2144 if (NULL == pWDA)
2145 {
2146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2147 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148 VOS_ASSERT(0);
2149 return VOS_STATUS_E_FAILURE;
2150 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2151 if (pWDA->wdiFailed == true)
2152 {
2153 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2154 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2155 return VOS_STATUS_E_ALREADY;
2156 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2157
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2158 /* FTM mode stay START_STATE */
2159 if( (WDA_READY_STATE != pWDA->wdaState) &&
2160 (WDA_INIT_STATE != pWDA->wdaState) &&
2161 (WDA_START_STATE != pWDA->wdaState) )
2162 {
2163 VOS_ASSERT(0);
2164 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2165 wdiStopReq = (WDI_StopReqParamsType *)
2166 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2167 if(NULL == wdiStopReq)
2168 {
2169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2170 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2171 VOS_ASSERT(0);
2172 return VOS_STATUS_E_NOMEM;
2173 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2174
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2175 wdiStopReq->wdiStopReason = reason;
2176 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2177
2178 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2179 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2180 {
2181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2182 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2183 VOS_ASSERT(0);
2184 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2185 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2186 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2187
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2188 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2189 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2190 {
2191 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2192 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2193 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2194
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2195 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2196 pWdaParams->wdaMsgParam = NULL;
2197 pWdaParams->pWdaContext = pWDA;
2198
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 /* call WDI stop */
2200 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2201 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2202
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2203 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2204 {
2205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2206 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2207 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2208 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2209 status = VOS_STATUS_E_FAILURE;
2210 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2211
2212 /* FTM Driver stop procedure should be synced.
2213 * Stop and Close will happen on same context */
2214 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2215 {
2216 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2217 WDI_RESPONSE_TIMEOUT);
2218 if (status != VOS_STATUS_SUCCESS)
2219 {
2220 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2221 "%s: FTM Stop Timepoout", __func__);
2222 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2223 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2224 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2225 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2226 return status;
2227}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2228/*
2229 * FUNCTION: WDA_close
2230 * call WDI_close and free the WDA context
2231 */
2232VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2233{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2234 VOS_STATUS status = VOS_STATUS_SUCCESS;
2235 WDI_Status wstatus;
2236 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2237 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2238 if (NULL == wdaContext)
2239 {
2240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2241 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2242 return VOS_STATUS_E_FAILURE;
2243 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2244 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2245 (WDA_STOP_STATE != wdaContext->wdaState))
2246 {
2247 VOS_ASSERT(0);
2248 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2249 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2250 wstatus = WDI_Close();
2251 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2252 {
2253 status = VOS_STATUS_E_FAILURE;
2254 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2255 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2256 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2257 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2258 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2259 {
2260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2261 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2262 status = VOS_STATUS_E_FAILURE;
2263 }
2264
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2265 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2266 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2267 {
2268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2269 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2270 status = VOS_STATUS_E_FAILURE;
2271 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2272 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2273 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2274 {
2275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2276 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2277 status = VOS_STATUS_E_FAILURE;
2278 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2279 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2280 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2281 {
2282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2283 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2284 status = VOS_STATUS_E_FAILURE;
2285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2287 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2288 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2289 {
2290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2291 "error in WDA close " );
2292 status = VOS_STATUS_E_FAILURE;
2293 }
2294 return status;
2295}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2296/*
2297 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2298 * returns 1 if the compiled version is greater than or equal to the input version
2299 */
2300
2301uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2302{
2303 VOS_STATUS status = VOS_STATUS_SUCCESS;
2304 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2305 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2306 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2307 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2308 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2309 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2310 (compiledVersion.revision >= revision)))
2311 return 1;
2312 else
2313 return 0;
2314}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2315/*
2316 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2317 * returns 1 if the compiled version is greater than or equal to the input version
2318 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2319uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2320{
2321 VOS_STATUS status = VOS_STATUS_SUCCESS;
2322 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2323 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2324 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2325 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2326 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2327 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2328 (reportedVersion.revision >= revision)))
2329 return 1;
2330 else
2331 return 0;
2332}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2333/*
2334 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2335 * Returns the version of the WCNSS WLAN API with which the HOST
2336 * device driver was compiled
2337 */
2338VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2339 tSirVersionType *pVersion)
2340{
2341 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2342 if ((NULL == pvosGCtx) || (NULL == pVersion))
2343 {
2344 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2345 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2346 VOS_ASSERT(0);
2347 return VOS_STATUS_E_FAILURE;
2348 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2350 if (NULL == pWDA )
2351 {
2352 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2353 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2354 VOS_ASSERT(0);
2355 return VOS_STATUS_E_FAILURE;
2356 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2357 *pVersion = pWDA->wcnssWlanCompiledVersion;
2358 return VOS_STATUS_SUCCESS;
2359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2360/*
2361 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2362 * Returns the version of the WCNSS WLAN API with which the WCNSS
2363 * device driver was compiled
2364 */
2365VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2366 tSirVersionType *pVersion)
2367{
2368 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2369 if ((NULL == pvosGCtx) || (NULL == pVersion))
2370 {
2371 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2372 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2373 VOS_ASSERT(0);
2374 return VOS_STATUS_E_FAILURE;
2375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2376 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2377 if (NULL == pWDA )
2378 {
2379 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2380 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2381 VOS_ASSERT(0);
2382 return VOS_STATUS_E_FAILURE;
2383 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2384 *pVersion = pWDA->wcnssWlanReportedVersion;
2385 return VOS_STATUS_SUCCESS;
2386}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2387/*
2388 * FUNCTION: WDA_GetWcnssSoftwareVersion
2389 * Returns the WCNSS Software version string
2390 */
2391VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2392 tANI_U8 *pVersion,
2393 tANI_U32 versionBufferSize)
2394{
2395 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2396 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2397 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2398 if ((NULL == pvosGCtx) || (NULL == pVersion))
2399 {
2400 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2401 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2402 VOS_ASSERT(0);
2403 return VOS_STATUS_E_FAILURE;
2404 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2405 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2406 if (NULL == pWDA )
2407 {
2408 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2409 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2410 VOS_ASSERT(0);
2411 return VOS_STATUS_E_FAILURE;
2412 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2413 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2414 return VOS_STATUS_SUCCESS;
2415}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2416/*
2417 * FUNCTION: WDA_GetWcnssHardwareVersion
2418 * Returns the WCNSS Hardware version string
2419 */
2420VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2421 tANI_U8 *pVersion,
2422 tANI_U32 versionBufferSize)
2423{
2424 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2425 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2426 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2427 if ((NULL == pvosGCtx) || (NULL == pVersion))
2428 {
2429 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2430 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2431 VOS_ASSERT(0);
2432 return VOS_STATUS_E_FAILURE;
2433 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2434 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2435 if (NULL == pWDA )
2436 {
2437 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2438 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2439 VOS_ASSERT(0);
2440 return VOS_STATUS_E_FAILURE;
2441 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2442 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2443 return VOS_STATUS_SUCCESS;
2444}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2445/*
2446 * FUNCTION: WDA_WniCfgDnld
2447 * Trigger CFG Download
2448 */
2449VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2450{
2451 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2452 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2453
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2454 if (NULL == pMac )
2455 {
2456 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2457 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 VOS_ASSERT(0);
2459 return VOS_STATUS_E_FAILURE;
2460 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2461 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2462 return vosStatus;
2463}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464/* -----------------------------------------------------------------
2465 * WDI interface
2466 * -----------------------------------------------------------------
2467 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2468/*
2469 * FUNCTION: WDA_suspendDataTxCallback
2470 * call back function called from TL after suspend Transmission
2471 */
2472VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2473 v_U8_t* ucSTAId,
2474 VOS_STATUS vosStatus)
2475{
2476 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2478 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2479 if (NULL == pWDA )
2480 {
2481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2482 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2483 VOS_ASSERT(0);
2484 return VOS_STATUS_E_FAILURE;
2485 }
2486 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2487 {
2488 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2489 }
2490 else
2491 {
2492 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2493 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2494 /* Trigger the event to bring the WDA TL suspend function to come
2495 * out of wait*/
2496 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2497 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2498 {
2499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2500 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2501 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2502 /* If TL suspended had timedout before this callback was called, resume back
2503 * TL.*/
2504 if (pWDA->txSuspendTimedOut)
2505 {
2506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2507 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2508 WDA_ResumeDataTx(pWDA);
2509 pWDA->txSuspendTimedOut = FALSE;
2510 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2511 return VOS_STATUS_SUCCESS;
2512}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2513/*
2514 * FUNCTION: WDA_suspendDataTx
2515 * Update TL to suspend the data Transmission
2516 */
2517VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2518{
2519 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2520 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2521
2522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2523 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2525 if (pWDA->txSuspendTimedOut)
2526 {
2527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2528 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2529 return status;
2530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2531 /* Reset the event to be not signalled */
2532 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2533 if(!VOS_IS_STATUS_SUCCESS(status))
2534 {
2535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2536 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2537 return VOS_STATUS_E_FAILURE;
2538 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2539 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2540 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 WDA_SuspendDataTxCallback);
2542 if(status != VOS_STATUS_SUCCESS)
2543 {
2544 return status;
2545 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2546 /* Wait for the event to be set by the TL, to get the response of
2547 * suspending the TX queues, this event should be set by the Callback
2548 * function called by TL*/
2549 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2550 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2551 if(!VOS_IS_STATUS_SUCCESS(status))
2552 {
2553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2554 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2555 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2556 /* Set this flag to true when TL suspend times out, so that when TL
2557 * suspend eventually happens and calls the callback, TL can be resumed
2558 * right away by looking at this flag when true.*/
2559 pWDA->txSuspendTimedOut = TRUE;
2560 }
2561 else
2562 {
2563 pWDA->txSuspendTimedOut = FALSE;
2564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2565 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2566 {
2567 status = VOS_STATUS_SUCCESS;
2568 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2569 return status;
2570}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2571/*
2572 * FUNCTION: WDA_resumeDataTx
2573 * Update TL to resume the data Transmission
2574 */
2575VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2576{
2577 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2578
2579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2580 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2581
2582 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2583 return status;
2584}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2585/*
2586 * FUNCTION: WDA_InitScanReqCallback
2587 * Trigger Init SCAN callback
2588 */
2589void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2590{
2591 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2592 tWDA_CbContext *pWDA;
2593 tInitScanParams *pWDA_ScanParam ;
2594 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2596 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2597 if(NULL == pWdaParams)
2598 {
2599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2600 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601 VOS_ASSERT(0) ;
2602 return ;
2603 }
2604 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2605 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2606 if(NULL == pWDA_ScanParam)
2607 {
2608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2609 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2610 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2611 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2612 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 return ;
2614 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2615 if(WDI_STATUS_SUCCESS != wdiStatus)
2616 {
2617 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2618 if(VOS_STATUS_SUCCESS != status)
2619 {
2620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2621 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 }
2623 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2624 /* free WDI command buffer */
2625 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2626 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2627
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2628
2629 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2630 /* without converting the Status to Failure or Success Just
2631 pass the same status to lim */
2632 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2633 /* send SCAN RSP message back to PE */
2634 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2635 return ;
2636}
2637
2638/*
2639 * FUNCTION: WDA_ProcessInitScanReq
2640 * Trigger Init SCAN in DAL
2641 */
2642VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2643 tInitScanParams *initScanParams)
2644{
2645 WDI_Status status = WDI_STATUS_SUCCESS ;
2646 WDI_InitScanReqParamsType *wdiInitScanParam =
2647 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2648 sizeof(WDI_InitScanReqParamsType)) ;
2649 tWDA_ReqParams *pWdaParams;
2650 tANI_U8 i = 0;
2651
2652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2653 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2654 if(NULL == wdiInitScanParam)
2655 {
2656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2657 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2658 VOS_ASSERT(0);
2659 return VOS_STATUS_E_NOMEM;
2660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2661 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2662 if(NULL == pWdaParams)
2663 {
2664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2665 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2666 VOS_ASSERT(0);
2667 vos_mem_free(wdiInitScanParam);
2668 return VOS_STATUS_E_NOMEM;
2669 }
2670
2671 /* Copy init Scan params to WDI structure */
2672 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2673 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2674 sizeof(tSirMacAddr)) ;
2675 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2676 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2677 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2678 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2679 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2680 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2681 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2682 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2683 {
2684 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2685 initScanParams->scanEntry.bssIdx[i] ;
2686 }
2687
2688 /* if Frame length, copy macMgmtHdr or WDI structure */
2689 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2690 {
2691 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2692 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2693 }
2694 wdiInitScanParam->wdiReqStatusCB = NULL ;
2695
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 /* Store Init Req pointer, as this will be used for response */
2697 pWdaParams->pWdaContext = pWDA;
2698 pWdaParams->wdaMsgParam = initScanParams;
2699 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2700 /* first try to suspend TX */
2701 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2702 if(WDI_STATUS_SUCCESS != status)
2703 {
2704 goto handleWdiFailure;
2705 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2706 /* call DAL API to pass init scan request to DAL */
2707 status = WDI_InitScanReq(wdiInitScanParam,
2708 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2709 if(IS_WDI_STATUS_FAILURE(status))
2710 {
2711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2712 "error in WDA Init Scan, Resume Tx " );
2713 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2714 VOS_ASSERT(0) ;
2715
2716 goto handleWdiFailure;
2717 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2718 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2719handleWdiFailure:
2720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2721 "Failure in WDI Api, free all the memory " );
2722 /* free WDI command buffer */
2723 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2724 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 /* send Failure to PE */
2726 initScanParams->status = eSIR_FAILURE ;
2727 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2728 return CONVERT_WDI2VOS_STATUS(status) ;
2729}
2730
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2731/*
2732 * FUNCTION: WDA_StartScanReqCallback
2733 * send Start SCAN RSP back to PE
2734 */
2735void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2736 void* pUserData)
2737{
2738 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2739 tWDA_CbContext *pWDA;
2740 tStartScanParams *pWDA_ScanParam;
2741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2742 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2743 if(NULL == pWdaParams)
2744 {
2745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2746 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747 VOS_ASSERT(0) ;
2748 return ;
2749 }
2750 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2751 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2752 if(NULL == pWDA_ScanParam)
2753 {
2754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2755 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2756 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2757 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2758 return ;
2759 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2760 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2761 {
2762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2763 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2764 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2765 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2766 return ;
2767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2769 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2771
2772 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2773 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2774 /* send SCAN RSP message back to PE */
2775 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2776 return ;
2777}
2778
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2779/*
2780 * FUNCTION: WDA_ProcessStartScanReq
2781 * Trigger start SCAN in WDI
2782 */
2783VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2784 tStartScanParams *startScanParams)
2785{
2786 WDI_Status status = WDI_STATUS_SUCCESS;
2787 WDI_StartScanReqParamsType *wdiStartScanParams =
2788 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2789 sizeof(WDI_StartScanReqParamsType)) ;
2790 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2792 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2793 if(NULL == wdiStartScanParams)
2794 {
2795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2796 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2797 VOS_ASSERT(0);
2798 return VOS_STATUS_E_NOMEM;
2799 }
2800 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2801 if(NULL == pWdaParams)
2802 {
2803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2804 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2805 VOS_ASSERT(0);
2806 vos_mem_free(wdiStartScanParams);
2807 return VOS_STATUS_E_NOMEM;
2808 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809 /* Copy init Scan params to WDI structure */
2810 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2811 wdiStartScanParams->wdiReqStatusCB = NULL ;
2812
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2813 /* Store Init Req pointer, as this will be used for response */
2814 /* store Params pass it to WDI */
2815 pWdaParams->pWdaContext = pWDA;
2816 pWdaParams->wdaMsgParam = startScanParams;
2817 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2818 /* call DAL API to pass init scan request to DAL */
2819 status = WDI_StartScanReq(wdiStartScanParams,
2820 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 /* failure returned by WDI API */
2822 if(IS_WDI_STATUS_FAILURE(status))
2823 {
2824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2825 "Failure in Start Scan WDI API, free all the memory "
2826 "It should be due to previous abort scan." );
2827 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2828 vos_mem_free(pWdaParams) ;
2829 startScanParams->status = eSIR_FAILURE ;
2830 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2832 return CONVERT_WDI2VOS_STATUS(status) ;
2833}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834/*
2835 * FUNCTION: WDA_EndScanReqCallback
2836 * END SCAN callback
2837 */
2838void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2839{
2840 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2841 tWDA_CbContext *pWDA;
2842 tEndScanParams *endScanParam;
2843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2844 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2845 if(NULL == pWdaParams)
2846 {
2847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2848 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2849 VOS_ASSERT(0) ;
2850 return ;
2851 }
2852 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2853 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2854 if(NULL == endScanParam)
2855 {
2856 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2857 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2858 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2860 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2861 return ;
2862 }
2863
2864 /* Free WDI command buffer */
2865 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2866 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2867 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2868 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2869 /* send response back to PE */
2870 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2871 return ;
2872}
2873
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874/*
2875 * FUNCTION: WDA_ProcessEndScanReq
2876 * Trigger END SCAN in WDI
2877 */
2878VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2879 tEndScanParams *endScanParams)
2880{
2881 WDI_Status status = WDI_STATUS_SUCCESS;
2882 WDI_EndScanReqParamsType *wdiEndScanParams =
2883 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2884 sizeof(WDI_EndScanReqParamsType)) ;
2885 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2887 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2888 if(NULL == wdiEndScanParams)
2889 {
2890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2891 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2892 VOS_ASSERT(0);
2893 return VOS_STATUS_E_NOMEM;
2894 }
2895 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2896 if(NULL == pWdaParams)
2897 {
2898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2899 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2900 VOS_ASSERT(0);
2901 vos_mem_free(wdiEndScanParams);
2902 return VOS_STATUS_E_NOMEM;
2903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 /* Copy init Scan params to WDI structure */
2905 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2906 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2907 /* Store Init Req pointer, as this will be used for response */
2908 /* store Params pass it to WDI */
2909 pWdaParams->pWdaContext = pWDA;
2910 pWdaParams->wdaMsgParam = endScanParams;
2911 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2912 /* call DAL API to pass init scan request to DAL */
2913 status = WDI_EndScanReq(wdiEndScanParams,
2914 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2915 if(IS_WDI_STATUS_FAILURE(status))
2916 {
2917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2918 "Failure in End Scan WDI API, free all the memory "
2919 "It should be due to previous abort scan." );
2920 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2921 vos_mem_free(pWdaParams) ;
2922 endScanParams->status = eSIR_FAILURE ;
2923 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2924 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2925 return CONVERT_WDI2VOS_STATUS(status) ;
2926}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2927/*
2928 * FUNCTION: WDA_FinishScanReqCallback
2929 * Trigger Finish SCAN callback
2930 */
2931void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2932{
2933 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2934 tWDA_CbContext *pWDA;
2935 tFinishScanParams *finishScanParam;
2936 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2938 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2939 if(NULL == pWdaParams)
2940 {
2941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2942 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943 VOS_ASSERT(0) ;
2944 return ;
2945 }
2946
2947 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2948 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2949 if(NULL == finishScanParam)
2950 {
2951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2952 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2954 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2955 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2956 return ;
2957 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2958 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2959 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2960 /*
2961 * Now Resume TX, if we reached here means, TX is already suspended, we
2962 * have to resume it unconditionaly
2963 */
2964 status = WDA_ResumeDataTx(pWDA) ;
2965
2966 if(VOS_STATUS_SUCCESS != status)
2967 {
2968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2969 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2970 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2971 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2973 return ;
2974}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2975/*
2976 * FUNCTION: WDA_ProcessFinshScanReq
2977 * Trigger Finish SCAN in WDI
2978 */
2979VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2980 tFinishScanParams *finishScanParams)
2981{
2982 WDI_Status status = WDI_STATUS_SUCCESS;
2983 WDI_FinishScanReqParamsType *wdiFinishScanParams =
2984 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
2985 sizeof(WDI_FinishScanReqParamsType)) ;
2986 tWDA_ReqParams *pWdaParams ;
2987 tANI_U8 i = 0;
2988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2989 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2990 if(NULL == wdiFinishScanParams)
2991 {
2992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2993 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2994 VOS_ASSERT(0);
2995 return VOS_STATUS_E_NOMEM;
2996 }
2997 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2998 if(NULL == pWdaParams)
2999 {
3000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3001 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3002 VOS_ASSERT(0);
3003 vos_mem_free(wdiFinishScanParams);
3004 return VOS_STATUS_E_NOMEM;
3005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 /* Copy init Scan params to WDI structure */
3007 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3008 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3009 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3010 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3011 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3012 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3013 finishScanParams->frameLength ;
3014 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3015 finishScanParams->currentOperChannel ;
3016 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3017 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3018 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3019 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3020 {
3021 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3022 finishScanParams->scanEntry.bssIdx[i] ;
3023 }
3024
3025
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 /* if Frame length, copy macMgmtHdr ro WDI structure */
3027 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3028 {
3029 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3030 &finishScanParams->macMgmtHdr,
3031 sizeof(WDI_MacMgmtHdr)) ;
3032 }
3033 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3034 /* Store Init Req pointer, as this will be used for response */
3035 /* store Params pass it to WDI */
3036 pWdaParams->pWdaContext = pWDA;
3037 pWdaParams->wdaMsgParam = finishScanParams;
3038 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3039 /* call DAL API to pass init scan request to DAL */
3040 status = WDI_FinishScanReq(wdiFinishScanParams,
3041 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3042
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3043
3044 /*
3045 * WDI API returns failure..
3046 */
3047 if(IS_WDI_STATUS_FAILURE( status))
3048 {
3049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3050 "Failure in Finish Scan WDI API, free all the memory " );
3051 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3052 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3053 finishScanParams->status = eSIR_FAILURE ;
3054 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3055 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3056 return CONVERT_WDI2VOS_STATUS(status) ;
3057}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3058/*---------------------------------------------------------------------
3059 * ASSOC API's
3060 *---------------------------------------------------------------------
3061 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3062/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3063 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3064 * Trigger Init SCAN callback
3065 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3066void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3067{
3068 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3069 tWDA_CbContext *pWDA;
3070 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3072 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3073 if(NULL == pWdaParams)
3074 {
3075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3076 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3077 VOS_ASSERT(0) ;
3078 return ;
3079 }
3080 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3081 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3082 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3083 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3084 /* reset macBSSID */
3085 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3086 /* reset macSTASelf */
3087 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3088 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3090 return ;
3091}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3092
3093/*
3094 * FUNCTION: WDA_JoinReqCallback
3095 * Free memory and send SWITCH CHANNEL RSP back to PE.
3096 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3097 */
3098void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3099{
3100 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3101 tWDA_CbContext *pWDA;
3102 tSwitchChannelParams *joinReqParam;
3103
3104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3105 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3106
3107 if(NULL == pWdaParams)
3108 {
3109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3110 "%s: pWdaParams received NULL", __func__);
3111 VOS_ASSERT(0);
3112 return;
3113 }
3114
3115 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3116 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3117 joinReqParam->status = wdiStatus;
3118
3119 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3120 {
3121 /* reset macBSSID */
3122 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3123 /* reset macSTASelf */
3124 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3125
3126 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3127 vos_mem_free(pWdaParams);
3128 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3129 }
3130
3131 return;
3132}
3133
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3134/*
3135 * FUNCTION: WDA_ProcessJoinReq
3136 * Trigger Join REQ in WDI
3137 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3138VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3139 tSwitchChannelParams* joinReqParam)
3140{
3141 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3142 WDI_JoinReqParamsType *wdiJoinReqParam =
3143 (WDI_JoinReqParamsType *)vos_mem_malloc(
3144 sizeof(WDI_JoinReqParamsType)) ;
3145 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3147 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3148 if(NULL == wdiJoinReqParam)
3149 {
3150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3151 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3152 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3153 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154 return VOS_STATUS_E_NOMEM;
3155 }
3156 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3157 if(NULL == pWdaParams)
3158 {
3159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3160 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3161 VOS_ASSERT(0);
3162 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3163 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3164 return VOS_STATUS_E_NOMEM;
3165 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3166
3167 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3168 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3169 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3170 {
3171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3172 "%s: received join request when BSSID or self-STA is NULL "
3173 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3174 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3175 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3176 VOS_ASSERT(0);
3177 vos_mem_free(wdiJoinReqParam);
3178 vos_mem_free(pWdaParams);
3179 joinReqParam->status = eSIR_FAILURE ;
3180 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3181 return VOS_STATUS_E_INVAL;
3182 }
3183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3184 /* copy the BSSID for pWDA */
3185 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3186 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3187 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3188 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3189 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3190 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3191#ifdef WLAN_FEATURE_VOWIFI
3192 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3193 joinReqParam->maxTxPower ;
3194#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3195 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3196 joinReqParam->localPowerConstraint ;
3197#endif
3198 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3199 joinReqParam->secondaryChannelOffset ;
3200 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3201
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3202 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3203 wdiJoinReqParam->pUserData = pWdaParams;
3204
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3205 /* Store Init Req pointer, as this will be used for response */
3206 /* store Params pass it to WDI */
3207 pWdaParams->pWdaContext = pWDA;
3208 pWdaParams->wdaMsgParam = joinReqParam;
3209 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3210 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3211 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3212 if(IS_WDI_STATUS_FAILURE(status))
3213 {
3214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3215 "Failure in Join WDI API, free all the memory " );
3216 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3217 vos_mem_free(pWdaParams) ;
3218 joinReqParam->status = eSIR_FAILURE ;
3219 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3221 return CONVERT_WDI2VOS_STATUS(status) ;
3222}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3223/*
3224 * FUNCTION: WDA_SwitchChannelReqCallback
3225 * send Switch channel RSP back to PE
3226 */
3227void WDA_SwitchChannelReqCallback(
3228 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3229{
3230 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3231 tWDA_CbContext *pWDA;
3232 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3234 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3235 if(NULL == pWdaParams)
3236 {
3237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3238 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239 VOS_ASSERT(0) ;
3240 return ;
3241 }
3242 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3243 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3244
3245#ifdef WLAN_FEATURE_VOWIFI
3246 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3247#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3248 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3249 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3250 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3251 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3252 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3253 return ;
3254}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3255/*
3256 * FUNCTION: WDA_ProcessChannelSwitchReq
3257 * Request to WDI to switch channel REQ params.
3258 */
3259VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3260 tSwitchChannelParams *pSwitchChanParams)
3261{
3262 WDI_Status status = WDI_STATUS_SUCCESS ;
3263 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3264 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3265 sizeof(WDI_SwitchChReqParamsType)) ;
3266 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3268 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3269 if(NULL == wdiSwitchChanParam)
3270 {
3271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3272 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3273 VOS_ASSERT(0);
3274 return VOS_STATUS_E_NOMEM;
3275 }
3276 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3277 if(NULL == pWdaParams)
3278 {
3279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3280 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3281 VOS_ASSERT(0);
3282 vos_mem_free(wdiSwitchChanParam);
3283 return VOS_STATUS_E_NOMEM;
3284 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3286#ifndef WLAN_FEATURE_VOWIFI
3287 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3288 pSwitchChanParams->localPowerConstraint;
3289#endif
3290 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3291 pSwitchChanParams->secondaryChannelOffset;
3292 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3293 /* Store req pointer, as this will be used for response */
3294 /* store Params pass it to WDI */
3295 pWdaParams->pWdaContext = pWDA;
3296 pWdaParams->wdaMsgParam = pSwitchChanParams;
3297 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3298#ifdef WLAN_FEATURE_VOWIFI
3299 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3300 = pSwitchChanParams->maxTxPower;
3301 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3302 pSwitchChanParams ->selfStaMacAddr,
3303 sizeof(tSirMacAddr));
3304#endif
3305 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3306 pSwitchChanParams->bssId,
3307 sizeof(tSirMacAddr));
3308
3309 status = WDI_SwitchChReq(wdiSwitchChanParam,
3310 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3311 if(IS_WDI_STATUS_FAILURE(status))
3312 {
3313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3314 "Failure in process channel switch Req WDI API, free all the memory " );
3315 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3316 vos_mem_free(pWdaParams) ;
3317 pSwitchChanParams->status = eSIR_FAILURE ;
3318 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3319 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3320 return CONVERT_WDI2VOS_STATUS(status) ;
3321}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3322
3323/*
3324 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3325 * send Switch channel RSP back to PE
3326 */
3327void WDA_SwitchChannelReqCallback_V1(
3328 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3329 void* pUserData)
3330{
3331 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3332 tWDA_CbContext *pWDA;
3333 tSwitchChannelParams *pSwitchChanParams;
3334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3335 "<------ %s " ,__func__);
3336
3337 if (NULL == pWdaParams)
3338 {
3339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3340 "%s: pWdaParams received NULL", __func__);
3341 VOS_ASSERT(0);
3342 return ;
3343 }
3344 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3345 pSwitchChanParams =
3346 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3347 pSwitchChanParams->channelSwitchSrc =
3348 wdiSwitchChanRsp->channelSwitchSrc;
3349#ifdef WLAN_FEATURE_VOWIFI
3350 pSwitchChanParams->txMgmtPower =
3351 wdiSwitchChanRsp->ucTxMgmtPower;
3352#endif
3353 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3354 vos_mem_free(pWdaParams);
3355 pSwitchChanParams->status =
3356 wdiSwitchChanRsp->wdiStatus ;
3357 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3358 (void *)pSwitchChanParams , 0);
3359 return;
3360}
3361
3362/*
3363 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3364 * Request to WDI to switch channel REQ params.
3365 */
3366VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3367 tSwitchChannelParams *pSwitchChanParams)
3368{
3369 WDI_Status status = WDI_STATUS_SUCCESS ;
3370 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3371 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3372 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3373 tWDA_ReqParams *pWdaParams ;
3374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3375 "------> %s " ,__func__);
3376 if (NULL == wdiSwitchChanParam)
3377 {
3378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3379 "%s: VOS MEM Alloc Failure", __func__);
3380 VOS_ASSERT(0);
3381 return VOS_STATUS_E_NOMEM;
3382 }
3383 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3384 if (NULL == pWdaParams)
3385 {
3386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3387 "%s: VOS MEM Alloc Failure", __func__);
3388 VOS_ASSERT(0);
3389 vos_mem_free(wdiSwitchChanParam);
3390 return VOS_STATUS_E_NOMEM;
3391 }
3392 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3393 pSwitchChanParams->channelSwitchSrc;
3394
3395 wdiSwitchChanParam->wdiChInfo.ucChannel =
3396 pSwitchChanParams->channelNumber;
3397#ifndef WLAN_FEATURE_VOWIFI
3398 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3399 pSwitchChanParams->localPowerConstraint;
3400#endif
3401 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3402 pSwitchChanParams->secondaryChannelOffset;
3403 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3404 /* Store req pointer, as this will be used for response */
3405 /* store Params pass it to WDI */
3406 pWdaParams->pWdaContext = pWDA;
3407 pWdaParams->wdaMsgParam = pSwitchChanParams;
3408 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3409#ifdef WLAN_FEATURE_VOWIFI
3410 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3411 pSwitchChanParams->maxTxPower;
3412 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3413 pSwitchChanParams ->selfStaMacAddr,
3414 sizeof(tSirMacAddr));
3415#endif
3416 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3417 pSwitchChanParams->bssId,
3418 sizeof(tSirMacAddr));
3419
3420 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3421 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3422 pWdaParams);
3423 if (IS_WDI_STATUS_FAILURE(status))
3424 {
3425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3426 "Failure in process channel switch Req WDI "
3427 "API, free all the memory " );
3428 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3429 vos_mem_free(pWdaParams) ;
3430 pSwitchChanParams->status = eSIR_FAILURE ;
3431 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3432 (void *)pSwitchChanParams, 0) ;
3433 }
3434 return CONVERT_WDI2VOS_STATUS(status) ;
3435}
3436
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3437/*
3438 * FUNCTION: WDA_ConfigBssReqCallback
3439 * config BSS Req Callback, called by WDI
3440 */
3441void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3442 ,void* pUserData)
3443{
3444 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3445 tWDA_CbContext *pWDA;
3446 tAddBssParams *configBssReqParam;
3447 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3449 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3450 if(NULL == pWdaParams)
3451 {
3452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3453 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3454 VOS_ASSERT(0) ;
3455 return ;
3456 }
3457 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3458 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3459 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3460 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3461 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3462 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3463 {
3464 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3465 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3467 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3468 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3469
3470 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3471 {
3472 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3473 {
3474 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3475 staConfigBssParam->staType = STA_ENTRY_BSSID;
3476 }
3477 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3478 (staConfigBssParam->staType == STA_ENTRY_SELF))
3479 {
3480 /* This is the 1st add BSS Req for the BTAMP STA */
3481 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3482 staConfigBssParam->staType = STA_ENTRY_BSSID;
3483 }
3484 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3485 (staConfigBssParam->staType == STA_ENTRY_PEER))
3486 {
3487 /* This is the 2nd ADD BSS Request that is sent
3488 * on the BTAMP STA side. The Sta type is
3489 * set to STA_ENTRY_PEER here.*/
3490 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3491 }
3492 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3493 (staConfigBssParam->staType == STA_ENTRY_SELF))
3494 {
3495 /* statype is already set by PE.
3496 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3497 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3498 staConfigBssParam->staType = STA_ENTRY_BSSID;
3499 }
3500 else
3501 {
3502 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3503 staConfigBssParam->staType = STA_ENTRY_PEER;
3504 }
3505 }
3506 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3507 {
3508 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3509 staConfigBssParam->staType = STA_ENTRY_SELF;
3510 }
3511 else
3512 {
3513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3514 "Invalid operation mode specified");
3515 VOS_ASSERT(0);
3516 }
3517
3518 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3519 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3520 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3521 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3522 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3523 sizeof(tSirMacAddr));
3524 staConfigBssParam->txChannelWidthSet =
3525 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3526 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3527 staConfigBssParam->htCapable)
3528 {
3529 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3530 wdiConfigBssRsp->ucBSSIdx;
3531 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3532 WDA_VALID_STA_INDEX ;
3533 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3534 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3535 wdiConfigBssRsp->ucBSSIdx,
3536 wdiConfigBssRsp->ucSTAIdx))
3537 {
3538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3539 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3540 VOS_ASSERT(0) ;
3541 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3542 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3543 {
3544 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3545 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3546 VOS_ASSERT(0) ;
3547 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3548#ifdef WLAN_FEATURE_VOWIFI
3549 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3550#endif
3551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3552 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3553 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3554 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3555 return ;
3556}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3557/*
3558 * FUNCTION: WDA_UpdateEdcaParamsForAC
3559 * Update WDI EDCA params with PE edca params
3560 */
3561void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3562 WDI_EdcaParamRecord *wdiEdcaParam,
3563 tSirMacEdcaParamRecord *macEdcaParam)
3564{
3565 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3566 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3567 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3568 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3569 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3570 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3571}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572/*
3573 * FUNCTION: WDA_ProcessConfigBssReq
3574 * Configure BSS before starting Assoc with AP
3575 */
3576VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3577 tAddBssParams* configBssReqParam)
3578{
3579 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3580 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3581 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3583 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3584 if (NULL == configBssReqParam)
3585 {
3586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3587 "%s: configBssReqParam is NULL", __func__);
3588 return VOS_STATUS_E_INVAL;
3589 }
3590
3591 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3592 sizeof(WDI_ConfigBSSReqParamsType)) ;
3593
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3594 if(NULL == wdiConfigBssReqParam)
3595 {
3596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3597 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3598 VOS_ASSERT(0);
3599 return VOS_STATUS_E_NOMEM;
3600 }
3601 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3602 if(NULL == pWdaParams)
3603 {
3604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3605 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3606 VOS_ASSERT(0);
3607 vos_mem_free(wdiConfigBssReqParam);
3608 return VOS_STATUS_E_NOMEM;
3609 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3611 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3612 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3613 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3614 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3615 /* Store Init Req pointer, as this will be used for response */
3616 /* store Params pass it to WDI */
3617 pWdaParams->pWdaContext = pWDA;
3618 pWdaParams->wdaMsgParam = configBssReqParam;
3619 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3620 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3621 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3622 if(IS_WDI_STATUS_FAILURE(status))
3623 {
3624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3625 "Failure in Config BSS WDI API, free all the memory " );
3626 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3627 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3628 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3629 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3631 return CONVERT_WDI2VOS_STATUS(status) ;
3632}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633#ifdef ENABLE_HAL_COMBINED_MESSAGES
3634/*
3635 * FUNCTION: WDA_PostAssocReqCallback
3636 * Post ASSOC req callback, send RSP back to PE
3637 */
3638void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3639 void* pUserData)
3640{
3641 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3642 tPostAssocParams *postAssocReqParam =
3643 (tPostAssocParams *)pWDA->wdaMsgParam ;
3644 /*STA context within the BSS Params*/
3645 tAddStaParams *staPostAssocParam =
3646 &postAssocReqParam->addBssParams.staContext ;
3647 /*STA Params for self STA*/
3648 tAddStaParams *selfStaPostAssocParam =
3649 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3651 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3652 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3653 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3654 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3655 {
3656 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3657 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3658 sizeof(tSirMacAddr)) ;
3659 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3660 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3661 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3662 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3663 }
3664 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3665 pWDA->wdaWdiApiMsgParam = NULL;
3666 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3667 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3668 return ;
3669}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670/*
3671 * FUNCTION: WDA_ProcessPostAssocReq
3672 * Trigger POST ASSOC processing in WDI
3673 */
3674VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3675 tPostAssocParams *postAssocReqParam)
3676{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3677 WDI_Status status = WDI_STATUS_SUCCESS ;
3678
3679 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3680 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3681 sizeof(WDI_PostAssocReqParamsType)) ;
3682 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3683 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3684
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 if(NULL == wdiPostAssocReqParam)
3686 {
3687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3688 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3689 VOS_ASSERT(0);
3690 return VOS_STATUS_E_NOMEM;
3691 }
3692
3693 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3694 {
3695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3696 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3697 VOS_ASSERT(0);
3698 return VOS_STATUS_E_FAILURE;
3699 }
3700
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3701 /* update BSS params into WDI structure */
3702 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3703 &postAssocReqParam->addBssParams) ;
3704 /* update STA params into WDI structure */
3705 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3706 &postAssocReqParam->addStaParams) ;
3707
3708 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3709 postAssocReqParam->addBssParams.highPerformance;
3710 WDA_UpdateEdcaParamsForAC(pWDA,
3711 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3712 &postAssocReqParam->addBssParams.acbe);
3713 WDA_UpdateEdcaParamsForAC(pWDA,
3714 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3715 &postAssocReqParam->addBssParams.acbk);
3716 WDA_UpdateEdcaParamsForAC(pWDA,
3717 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3718 &postAssocReqParam->addBssParams.acvi);
3719 WDA_UpdateEdcaParamsForAC(pWDA,
3720 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3721 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3722 /* Store Init Req pointer, as this will be used for response */
3723 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3724 /* store Params pass it to WDI */
3725 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3726 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3727 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3728 if(IS_WDI_STATUS_FAILURE(status))
3729 {
3730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3731 "Failure in Post Assoc WDI API, free all the memory " );
3732 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3733 pWDA->wdaWdiApiMsgParam = NULL;
3734 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3735 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3736 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3737 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3738 return CONVERT_WDI2VOS_STATUS(status) ;
3739}
3740#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3741/*
3742 * FUNCTION: WDA_AddStaReqCallback
3743 * ADD STA req callback, send RSP back to PE
3744 */
3745void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3746 void* pUserData)
3747{
3748 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3749 tWDA_CbContext *pWDA;
3750 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3752 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3753 if(NULL == pWdaParams)
3754 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3755 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]3756 VOS_ASSERT(0) ;
3757 return ;
3758 }
3759 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3760 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3761 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3762 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3763 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3764 {
3765 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3766 /*TODO: UMAC structure doesn't have these fields*/
3767 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3768 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3769 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3770 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3771 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3772 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3773#ifdef FEATURE_WLAN_TDLS
3774 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3775 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3776#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3777 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3778#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3779 {
3780 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3781 wdiConfigStaRsp->ucBssIdx;
3782 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3783 WDA_VALID_STA_INDEX ;
3784 }
3785 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3786 {
3787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3788 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3789 VOS_ASSERT(0) ;
3790 return ;
3791 }
3792 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3793 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3794 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3795 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3796 return ;
3797}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3798/*
3799 * FUNCTION: WDA_ConfigStaReq
3800 * Trigger Config STA processing in WDI
3801 */
3802VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3803 tAddStaParams *addStaReqParam)
3804{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3805 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3806 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3807 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3808 sizeof(WDI_ConfigSTAReqParamsType)) ;
3809 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3811 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3812 if(NULL == wdiConfigStaReqParam)
3813 {
3814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3815 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3816 VOS_ASSERT(0);
3817 return VOS_STATUS_E_NOMEM;
3818 }
3819 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3820 if(NULL == pWdaParams)
3821 {
3822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3823 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3824 VOS_ASSERT(0);
3825 vos_mem_free(wdiConfigStaReqParam);
3826 return VOS_STATUS_E_NOMEM;
3827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3828 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3829 /* update STA params into WDI structure */
3830 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3831 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3832 /* Store Init Req pointer, as this will be used for response */
3833 /* store Params pass it to WDI */
3834 pWdaParams->pWdaContext = pWDA;
3835 pWdaParams->wdaMsgParam = addStaReqParam;
3836 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3837 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3838 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3839 if(IS_WDI_STATUS_FAILURE(status))
3840 {
3841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3842 "Failure in Config STA WDI API, free all the memory " );
3843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3844 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3845 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3846 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3848 return CONVERT_WDI2VOS_STATUS(status) ;
3849}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3850/*
3851 * FUNCTION: WDA_DelBSSReqCallback
3852 * Dens DEL BSS RSP back to PE
3853 */
3854void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3855 void* pUserData)
3856{
3857 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3858 tWDA_CbContext *pWDA;
3859 tDeleteBssParams *delBssReqParam;
3860 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3862 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3863 if(NULL == pWdaParams)
3864 {
3865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3866 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3867 VOS_ASSERT(0) ;
3868 return ;
3869 }
3870 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3871 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3872 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3873 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3874 {
3875 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3876 sizeof(tSirMacAddr)) ;
3877 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3878 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3879 {
3880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3881 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3882 VOS_ASSERT(0) ;
3883 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3884 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3885 {
3886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3887 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3888 VOS_ASSERT(0) ;
3889 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3890 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3891 {
3892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3893 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3894 VOS_ASSERT(0) ;
3895 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3896
3897 WLANTL_StartForwarding(staIdx,0,0);
3898
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3899 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3900 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3901 /* reset the the system role*/
3902 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3903
3904 /* Reset the BA related information */
3905 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3906 {
3907 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3908 {
3909 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3910 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
3911 /* Reset framesTxed counters here */
3912 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3913 {
3914 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3915 }
3916 }
3917 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3918 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3919 return ;
3920}
3921
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3922/*
3923 * FUNCTION: WDA_ProcessDelBssReq
3924 * Init DEL BSS req with WDI
3925 */
3926VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3927 tDeleteBssParams *delBssParam)
3928{
3929 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3930 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3931 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3932 sizeof(WDI_DelBSSReqParamsType)) ;
3933 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3935 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3936 if(NULL == wdiDelBssReqParam)
3937 {
3938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3939 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3940 VOS_ASSERT(0);
3941 return VOS_STATUS_E_NOMEM;
3942 }
3943 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3944 if(NULL == pWdaParams)
3945 {
3946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3947 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3948 VOS_ASSERT(0);
3949 vos_mem_free(wdiDelBssReqParam);
3950 return VOS_STATUS_E_NOMEM;
3951 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3952 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3953 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3954
3955 /* Store Init Req pointer, as this will be used for response */
3956 /* store Params pass it to WDI */
3957 pWdaParams->pWdaContext = pWDA;
3958 pWdaParams->wdaMsgParam = delBssParam;
3959 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 status = WDI_DelBSSReq(wdiDelBssReqParam,
3961 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3962 if(IS_WDI_STATUS_FAILURE(status))
3963 {
3964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3965 "Failure in Del BSS WDI API, free all the memory " );
3966 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3967 vos_mem_free(pWdaParams) ;
3968 delBssParam->status = eSIR_FAILURE ;
3969 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3970 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3971 return CONVERT_WDI2VOS_STATUS(status) ;
3972}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3973/*
3974 * FUNCTION: WDA_DelSTAReqCallback
3975 * Dens DEL STA RSP back to PE
3976 */
3977void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3978 void* pUserData)
3979{
3980 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3981 tWDA_CbContext *pWDA;
3982 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3984 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3985 if(NULL == pWdaParams)
3986 {
3987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3988 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3989 VOS_ASSERT(0) ;
3990 return ;
3991 }
3992 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3993 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3994 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3995 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
3996 {
3997 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
3998 {
3999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4000 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4001 VOS_ASSERT(0) ;
4002 }
4003 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4004 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4005 }
4006 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4007 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4008 /*Reset the BA information corresponding to this STAIdx */
4009 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4010 WDA_INVALID_STA_INDEX;
4011 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
4012
4013 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4014 return ;
4015}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4016/*
4017 * FUNCTION: WDA_ProcessDelStaReq
4018 * Init DEL STA req with WDI
4019 */
4020VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4021 tDeleteStaParams *delStaParam)
4022{
4023 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4024 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4025 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4026 sizeof(WDI_DelSTAReqParamsType)) ;
4027 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4029 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4030 if(NULL == wdiDelStaReqParam)
4031 {
4032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4033 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4034 VOS_ASSERT(0);
4035 return VOS_STATUS_E_NOMEM;
4036 }
4037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4038 if(NULL == pWdaParams)
4039 {
4040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4042 VOS_ASSERT(0);
4043 vos_mem_free(wdiDelStaReqParam);
4044 return VOS_STATUS_E_NOMEM;
4045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4046 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
4047 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4048 /* Store Init Req pointer, as this will be used for response */
4049 /* store Params pass it to WDI */
4050 pWdaParams->pWdaContext = pWDA;
4051 pWdaParams->wdaMsgParam = delStaParam;
4052 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4053 status = WDI_DelSTAReq(wdiDelStaReqParam,
4054 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4055 if(IS_WDI_STATUS_FAILURE(status))
4056 {
4057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4058 "Failure in Del STA WDI API, free all the memory status = %d",
4059 status );
4060 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4061 vos_mem_free(pWdaParams) ;
4062 delStaParam->status = eSIR_FAILURE ;
4063 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4065 return CONVERT_WDI2VOS_STATUS(status) ;
4066}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4067void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
4068{
4069 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4070 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4071 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4073 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4074 if(NULL == pWdaParams)
4075 {
4076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4077 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4078 VOS_ASSERT(0) ;
4079 return ;
4080 }
4081 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4082 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4083 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4084 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4085 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4086 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4087 pwdiAddSTASelfRsp->macSelfSta,
4088 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4089 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4090 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4091 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4092 {
4093 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4094 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
4095 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4096 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4097 return ;
4098}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4099
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4100/*
4101 * FUNCTION: WDA_ProcessAddStaSelfReq
4102 *
4103 */
4104VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4105{
4106 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4107 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4108 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4109 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4110 sizeof(WDI_AddSTASelfReqParamsType)) ;
4111 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4113 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4114 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4115 if( NULL == wdiAddStaSelfReq )
4116 {
4117 VOS_ASSERT( 0 );
4118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4119 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4120 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4121 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4122 return( VOS_STATUS_E_NOMEM );
4123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4124 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4125 if( NULL == pWdaParams )
4126 {
4127 VOS_ASSERT( 0 );
4128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4129 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4130 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4131 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4132 vos_mem_free(wdiAddStaSelfReq) ;
4133 return( VOS_STATUS_E_NOMEM );
4134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4135 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4136 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4137 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4138 /* Store Init Req pointer, as this will be used for response */
4139 /* store Params pass it to WDI */
4140 pWdaParams->pWdaContext = pWDA;
4141 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4142 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4143 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4144
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4145 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4146 {
4147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4148 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4149 wstatus );
4150 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4152 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4153 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4154 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4155 pAddStaSelfReq->status = eSIR_FAILURE ;
4156 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4157 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4158 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4160/*
4161 * FUNCTION: WDA_DelSTASelfRespCallback
4162 *
4163 */
4164void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4165 wdiDelStaSelfRspParams , void* pUserData)
4166{
4167 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4168 tWDA_CbContext *pWDA;
4169 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4171 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4172 if (NULL == pWdaParams)
4173 {
4174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4175 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4176 VOS_ASSERT(0);
4177 return;
4178 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4179 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4180 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4181 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4182 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183
4184 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4185 vos_mem_free(pWdaParams) ;
4186
4187 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4188 return ;
4189}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4190/*
4191 * FUNCTION: WDA_DelSTASelfReqCallback
4192 *
4193 */
4194void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4195 void* pUserData)
4196{
4197 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4198 tWDA_CbContext *pWDA;
4199 tDelStaSelfParams *delStaSelfParams;
4200
4201 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4202 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4203 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4204
4205 if (NULL == pWdaParams)
4206 {
4207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4208 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4209 VOS_ASSERT(0);
4210 return;
4211 }
4212
4213 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4214 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4215
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4216 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4217
4218 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4219 {
4220 VOS_ASSERT(0);
4221 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4222 vos_mem_free(pWdaParams) ;
4223 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4224 }
4225
4226 return ;
4227}
4228
4229/*
4230 * FUNCTION: WDA_DelSTASelfReq
4231 * Trigger Config STA processing in WDI
4232 */
4233VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4234 tDelStaSelfParams* pDelStaSelfReqParam)
4235{
4236 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4237 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4238 tWDA_ReqParams *pWdaParams = NULL;
4239 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4240 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4241 sizeof(WDI_DelSTASelfReqParamsType)) ;
4242
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4244 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4245 if( NULL == wdiDelStaSelfReq )
4246 {
4247 VOS_ASSERT( 0 );
4248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4249 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4250 return( VOS_STATUS_E_NOMEM );
4251 }
4252
4253 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4254 if( NULL == pWdaParams )
4255 {
4256 VOS_ASSERT( 0 );
4257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4258 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4259 vos_mem_free(wdiDelStaSelfReq) ;
4260 return( VOS_STATUS_E_NOMEM );
4261 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4262 pWdaParams->pWdaContext = pWDA;
4263 /* Store param pointer as passed in by caller */
4264 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4265 /* store Params pass it to WDI */
4266 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4267 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4268 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4269
4270 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4271 wdiDelStaSelfReq->pUserData = pWdaParams;
4272
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4273 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4274 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4275
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4276 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4277 {
4278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4279 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4280 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4281 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4282 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4283 vos_mem_free(pWdaParams) ;
4284 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4285 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4286 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4287 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4288}
4289
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4290/*
4291 * FUNCTION: WDA_SendMsg
4292 * Send Message back to PE
4293 */
4294void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4295 void *pBodyptr, tANI_U32 bodyVal)
4296{
4297 tSirMsgQ msg = {0} ;
4298 tANI_U32 status = VOS_STATUS_SUCCESS ;
4299 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4300 msg.type = msgType;
4301 msg.bodyval = bodyVal;
4302 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4303 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4304 if (VOS_STATUS_SUCCESS != status)
4305 {
4306 if(NULL != pBodyptr)
4307 {
4308 vos_mem_free(pBodyptr);
4309 }
4310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4311 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4312 VOS_ASSERT(0) ;
4313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4314 return ;
4315}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4316/*
4317 * FUNCTION: WDA_UpdateBSSParams
4318 * Translated WDA/PE BSS info into WDI BSS info..
4319 */
4320void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4321 WDI_ConfigBSSReqInfoType *wdiBssParams,
4322 tAddBssParams *wdaBssParams)
4323{
4324 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4325 /* copy bssReq Params to WDI structure */
4326 vos_mem_copy(wdiBssParams->macBSSID,
4327 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4328 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4329 sizeof(tSirMacAddr)) ;
4330 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4331 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4332 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4333 wdiBssParams->ucShortSlotTimeSupported =
4334 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4335 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4336 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4337 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4338 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4339 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4340
4341 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4342 wdiBssParams->ucTXOPProtectionFullSupport =
4343 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4344 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4345 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4346 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4347 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4348 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4349 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4350 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4351
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4352 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4354 /* copy SSID into WDI structure */
4355 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4356 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4357 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4358 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4359 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4360 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4361#ifdef WLAN_FEATURE_VOWIFI
4362 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4363#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4364 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4365 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4366#ifdef WLAN_FEATURE_VOWIFI_11R
4367 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4368 if(wdiBssParams->bExtSetStaKeyParamValid)
4369 {
4370 /* copy set STA key params to WDI structure */
4371 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4372 wdaBssParams->extSetStaKeyParam.staIdx;
4373 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4374 wdaBssParams->extSetStaKeyParam.encType;
4375 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4376 wdaBssParams->extSetStaKeyParam.wepType;
4377 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4378 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4379 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4380 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4381 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4382 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4383 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4384 {
4385 WDA_GetWepKeysFromCfg( pWDA,
4386 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4387 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4388 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4389 }
4390 else
4391 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4392 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4393 keyIndex++)
4394 {
4395 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4396 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4397 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4398 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4399 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4400 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4401 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4402 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4403 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4404 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4405 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4406 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4407 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4408 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4409 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4410 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4411 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4412 }
4413 }
4414 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4415 }
4416 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4417 {
4418 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4419 sizeof(wdaBssParams->extSetStaKeyParam) );
4420 }
4421#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4422#ifdef WLAN_FEATURE_11AC
4423 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4424 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4425#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4426
4427 return ;
4428}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4429/*
4430 * FUNCTION: WDA_UpdateSTAParams
4431 * Translated WDA/PE BSS info into WDI BSS info..
4432 */
4433void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4434 WDI_ConfigStaReqInfoType *wdiStaParams,
4435 tAddStaParams *wdaStaParams)
4436{
4437 tANI_U8 i = 0;
4438 /* Update STA params */
4439 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4440 sizeof(tSirMacAddr)) ;
4441 wdiStaParams->usAssocId = wdaStaParams->assocId;
4442 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4443 wdiStaParams->staIdx = wdaStaParams->staIdx;
4444
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4445 wdiStaParams->ucShortPreambleSupported =
4446 wdaStaParams->shortPreambleSupported;
4447 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4448 sizeof(tSirMacAddr)) ;
4449 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4450
4451 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4452
4453 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4454 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4455 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4456 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4457 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4458 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4459 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4460
4461 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4462 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4463 wdiStaParams->wdiSupportedRates.opRateMode =
4464 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4465 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4466 {
4467 wdiStaParams->wdiSupportedRates.llbRates[i] =
4468 wdaStaParams->supportedRates.llbRates[i];
4469 }
4470 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4471 {
4472 wdiStaParams->wdiSupportedRates.llaRates[i] =
4473 wdaStaParams->supportedRates.llaRates[i];
4474 }
4475 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4476 {
4477 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4478 wdaStaParams->supportedRates.aniLegacyRates[i];
4479 }
4480 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4481 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4482#ifdef WLAN_FEATURE_11AC
4483 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4484 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4485 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4486 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4487#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4488 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4489 {
4490 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4491 wdaStaParams->supportedRates.supportedMCSSet[i];
4492 }
4493 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4494 wdaStaParams->supportedRates.rxHighestDataRate;
4495
4496 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4497
4498 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4499
4500 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4501 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4502 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4503
4504 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4505 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4506 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4507 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4508 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4509#ifdef WLAN_FEATURE_11AC
4510 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4511 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4512 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4513 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4514 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4515 * must be set by default */
4516 if ( wdiStaParams->vhtTxMUBformeeCapable )
4517 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4518#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4519 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4520 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4521 return ;
4522}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4523/*
4524 * -------------------------------------------------------------------------
4525 * CFG update to WDI
4526 * -------------------------------------------------------------------------
4527 */
4528
4529 /*
4530 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4531 * Convert the WNI CFG ID to HAL CFG ID
4532 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4533static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4534{
4535 switch(wniCfgId)
4536 {
4537 case WNI_CFG_STA_ID:
4538 return QWLAN_HAL_CFG_STA_ID;
4539 case WNI_CFG_CURRENT_TX_ANTENNA:
4540 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4541 case WNI_CFG_CURRENT_RX_ANTENNA:
4542 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4543 case WNI_CFG_LOW_GAIN_OVERRIDE:
4544 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4545 case WNI_CFG_POWER_STATE_PER_CHAIN:
4546 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4547 case WNI_CFG_CAL_PERIOD:
4548 return QWLAN_HAL_CFG_CAL_PERIOD;
4549 case WNI_CFG_CAL_CONTROL:
4550 return QWLAN_HAL_CFG_CAL_CONTROL;
4551 case WNI_CFG_PROXIMITY:
4552 return QWLAN_HAL_CFG_PROXIMITY;
4553 case WNI_CFG_NETWORK_DENSITY:
4554 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4555 case WNI_CFG_MAX_MEDIUM_TIME:
4556 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4557 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4558 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4559 case WNI_CFG_RTS_THRESHOLD:
4560 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4561 case WNI_CFG_SHORT_RETRY_LIMIT:
4562 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4563 case WNI_CFG_LONG_RETRY_LIMIT:
4564 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4565 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4566 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4567 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4568 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4569 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4570 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4571 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4572 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4573 case WNI_CFG_FIXED_RATE:
4574 return QWLAN_HAL_CFG_FIXED_RATE;
4575 case WNI_CFG_RETRYRATE_POLICY:
4576 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4577 case WNI_CFG_RETRYRATE_SECONDARY:
4578 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4579 case WNI_CFG_RETRYRATE_TERTIARY:
4580 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4581 case WNI_CFG_FORCE_POLICY_PROTECTION:
4582 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4583 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4584 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4585 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4586 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4587 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4588 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4589 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4590 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4591 case WNI_CFG_MAX_BA_SESSIONS:
4592 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4593 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4594 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4595 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4596 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4597 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4598 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4599 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4600 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4601 case WNI_CFG_STATS_PERIOD:
4602 return QWLAN_HAL_CFG_STATS_PERIOD;
4603 case WNI_CFG_CFP_MAX_DURATION:
4604 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4605#if 0 /*This is not part of CFG*/
4606 case WNI_CFG_FRAME_TRANS_ENABLED:
4607 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4608#endif
4609 case WNI_CFG_DTIM_PERIOD:
4610 return QWLAN_HAL_CFG_DTIM_PERIOD;
4611 case WNI_CFG_EDCA_WME_ACBK:
4612 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4613 case WNI_CFG_EDCA_WME_ACBE:
4614 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4615 case WNI_CFG_EDCA_WME_ACVI:
4616 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4617 case WNI_CFG_EDCA_WME_ACVO:
4618 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4619#if 0
4620 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4621 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4622 case WNI_CFG_TELE_BCN_TRANS_LI:
4623 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4624 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4625 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4626 case WNI_CFG_TELE_BCN_MAX_LI:
4627 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4628 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4629 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4630#endif
4631 case WNI_CFG_ENABLE_CLOSE_LOOP:
4632 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4633 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4634 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4635 default:
4636 {
4637 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4638 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4639 wniCfgId);
4640 return VOS_STATUS_E_INVAL;
4641 }
4642 }
4643}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4644/*
4645 * FUNCTION: WDA_UpdateCfgCallback
4646 *
4647 */
4648void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4649{
4650 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4651 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4652 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4654 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4655 /*
4656 * currently there is no response message is expected between PE and
4657 * WDA, Failure return from WDI is a ASSERT condition
4658 */
4659 if(WDI_STATUS_SUCCESS != wdiStatus)
4660 {
4661 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4662 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4663 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4664 }
4665
4666 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4667 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4668 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4669 return ;
4670}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4671/*
4672 * FUNCTION: WDA_UpdateCfg
4673 *
4674 */
4675VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4676{
4677
4678 WDI_Status status = WDI_STATUS_SUCCESS ;
4679 tANI_U32 val =0;
4680 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4681 tHalCfg *configData;
4682 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4683 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4685 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4686 if (NULL == pMac )
4687 {
4688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4689 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4690 return VOS_STATUS_E_FAILURE;
4691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4692 if(WDA_START_STATE != pWDA->wdaState)
4693 {
4694 return VOS_STATUS_E_FAILURE;
4695 }
4696
4697 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4698 {
4699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4700 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4701 VOS_ASSERT(0);
4702 return VOS_STATUS_E_FAILURE;
4703 }
4704
4705 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4706 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4707 if(NULL == wdiCfgReqParam)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4711 VOS_ASSERT(0);
4712 return VOS_STATUS_E_NOMEM;
4713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4715 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4716 if(NULL == wdiCfgReqParam->pConfigBuffer)
4717 {
4718 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4719 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4720 vos_mem_free(wdiCfgReqParam);
4721 VOS_ASSERT(0);
4722 return VOS_STATUS_E_NOMEM;
4723 }
4724
4725 /*convert the WNI CFG Id to HAL CFG Id*/
4726 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4727 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4728
4729 /*TODO: revisit this for handling string parameters */
4730 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4731 &val) != eSIR_SUCCESS)
4732 {
4733 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4734 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4735 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4736 vos_mem_free(wdiCfgReqParam);
4737 return eSIR_FAILURE;
4738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4739 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4740 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4741 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4742 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4743 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4744
4745 /* store Params pass it to WDI */
4746 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4747#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4748 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4749 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4750 if(IS_WDI_STATUS_FAILURE(status))
4751 {
4752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4753 "Failure in Update CFG WDI API, free all the memory " );
4754 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4755 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4756 pWDA->wdaWdiCfgApiMsgParam = NULL;
4757 /* Failure is not expected */
4758 VOS_ASSERT(0) ;
4759 }
4760#else
4761 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4762 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4763 pWDA->wdaWdiCfgApiMsgParam = NULL;
4764#endif
4765 return CONVERT_WDI2VOS_STATUS(status) ;
4766}
4767
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4768VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4769 v_U8_t *pDefaultKeyId,
4770 v_U8_t *pNumKeys,
4771 WDI_KeysType *pWdiKeys )
4772{
4773 v_U32_t i, j, defKeyId = 0;
4774 v_U32_t val = SIR_MAC_KEY_LENGTH;
4775 VOS_STATUS status = WDI_STATUS_SUCCESS;
4776 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4777 if (NULL == pMac )
4778 {
4779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4780 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4781 return VOS_STATUS_E_FAILURE;
4782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4783 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4784 &defKeyId ))
4785 {
4786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4787 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4788 }
4789
4790 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4791 /* Need to extract ALL of the configured WEP Keys */
4792 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4793 {
4794 val = SIR_MAC_KEY_LENGTH;
4795 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4796 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4797 pWdiKeys[j].key,
4798 &val ))
4799 {
4800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4801 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4802 }
4803 else
4804 {
4805 pWdiKeys[j].keyId = (tANI_U8) i;
4806 /*
4807 * Actually, a DC (Don't Care) because
4808 * this is determined (and set) by PE/MLME
4809 */
4810 pWdiKeys[j].unicast = 0;
4811 /*
4812 * Another DC (Don't Care)
4813 */
4814 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4815 /* Another DC (Don't Care). Unused for WEP */
4816 pWdiKeys[j].paeRole = 0;
4817 /* Determined from wlan_cfgGetStr() above.*/
4818 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4819 j++;
4820 *pNumKeys = (tANI_U8) j;
4821 }
4822 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4823 return status;
4824}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4825/*
4826 * FUNCTION: WDA_SetBssKeyReqCallback
4827 * send SET BSS key RSP back to PE
4828 */
4829void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4830{
4831 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4832 tWDA_CbContext *pWDA;
4833 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4835 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4836 if(NULL == pWdaParams)
4837 {
4838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4839 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4840 VOS_ASSERT(0) ;
4841 return ;
4842 }
4843 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4844 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4845 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4846 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4847 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4848 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849 return ;
4850}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4851/*
4852 * FUNCTION: WDA_ProcessSetBssKeyReq
4853 * Request to WDI for programming the BSS key( key for
4854 * broadcast/multicast frames Encryption)
4855 */
4856VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4857 tSetBssKeyParams *setBssKeyParams )
4858{
4859 WDI_Status status = WDI_STATUS_SUCCESS ;
4860 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4861 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4862 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4863 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4864 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4866 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4867 if(NULL == wdiSetBssKeyParam)
4868 {
4869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4870 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871 VOS_ASSERT(0);
4872 return VOS_STATUS_E_NOMEM;
4873 }
4874 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4875 if(NULL == pWdaParams)
4876 {
4877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4878 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4879 VOS_ASSERT(0);
4880 vos_mem_free(wdiSetBssKeyParam);
4881 return VOS_STATUS_E_NOMEM;
4882 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4883 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4884 /* copy set BSS params to WDI structure */
4885 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4886 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4887 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4888 if(setBssKeyParams->encType != eSIR_ED_NONE)
4889 {
4890 if( setBssKeyParams->numKeys == 0 &&
4891 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4892 setBssKeyParams->encType == eSIR_ED_WEP104))
4893 {
4894 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4895 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4896 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4897 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4898 }
4899 else
4900 {
4901 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4902 {
4903 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4904 setBssKeyParams->key[keyIndex].keyId;
4905 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4906 setBssKeyParams->key[keyIndex].unicast;
4907 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4908 setBssKeyParams->key[keyIndex].keyDirection;
4909 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4910 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4911 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4912 setBssKeyParams->key[keyIndex].paeRole;
4913 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4914 setBssKeyParams->key[keyIndex].keyLength;
4915 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4916 setBssKeyParams->key[keyIndex].key,
4917 SIR_MAC_MAX_KEY_LENGTH);
4918 }
4919 }
4920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4922 setBssKeyParams->singleTidRc;
4923 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4924 /* Store set key pointer, as this will be used for response */
4925 /* store Params pass it to WDI */
4926 pWdaParams->pWdaContext = pWDA;
4927 pWdaParams->wdaMsgParam = setBssKeyParams;
4928 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4929 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4930 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4931
4932 if(IS_WDI_STATUS_FAILURE(status))
4933 {
4934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4935 "Failure in Set BSS Key Req WDI API, free all the memory " );
4936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4937 vos_mem_free(pWdaParams) ;
4938 setBssKeyParams->status = eSIR_FAILURE ;
4939 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4941 return CONVERT_WDI2VOS_STATUS(status) ;
4942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4943/*
4944 * FUNCTION: WDA_RemoveBssKeyReqCallback
4945 * send SET BSS key RSP back to PE
4946 */
4947void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4948{
4949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4950 tWDA_CbContext *pWDA;
4951 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4953 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4954 if(NULL == pWdaParams)
4955 {
4956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4957 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4958 VOS_ASSERT(0) ;
4959 return ;
4960 }
4961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4962 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4964 vos_mem_free(pWdaParams) ;
4965
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4966 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4967 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4968 return ;
4969}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4970/*
4971 * FUNCTION: WDA_ProcessRemoveBssKeyReq
4972 * Request to WDI to remove the BSS key( key for broadcast/multicast
4973 * frames Encryption)
4974 */
4975VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
4976 tRemoveBssKeyParams *removeBssKeyParams )
4977{
4978 WDI_Status status = WDI_STATUS_SUCCESS ;
4979 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
4980 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
4981 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
4982 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4984 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4985 if(NULL == wdiRemoveBssKeyParam)
4986 {
4987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4988 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4989 VOS_ASSERT(0);
4990 return VOS_STATUS_E_NOMEM;
4991 }
4992 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4993 if(NULL == pWdaParams)
4994 {
4995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4996 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4997 VOS_ASSERT(0);
4998 vos_mem_free(wdiRemoveBssKeyParam);
4999 return VOS_STATUS_E_NOMEM;
5000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5001 /* copy Remove BSS key params to WDI structure*/
5002 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5003 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5004 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5005 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5006 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5007 /* Store remove key pointer, as this will be used for response */
5008 /* store Params pass it to WDI */
5009 pWdaParams->pWdaContext = pWDA;
5010 pWdaParams->wdaMsgParam = removeBssKeyParams;
5011 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5012 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5013 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5014 if(IS_WDI_STATUS_FAILURE(status))
5015 {
5016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5017 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5018 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5019 vos_mem_free(pWdaParams) ;
5020 removeBssKeyParams->status = eSIR_FAILURE ;
5021 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5022 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5023 return CONVERT_WDI2VOS_STATUS(status) ;
5024}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5025/*
5026 * FUNCTION: WDA_SetBssKeyReqCallback
5027 * send SET BSS key RSP back to PE
5028 */
5029void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5030{
5031 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5032 tWDA_CbContext *pWDA;
5033 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5035 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5036 if(NULL == pWdaParams)
5037 {
5038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5039 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5040 VOS_ASSERT(0) ;
5041 return ;
5042 }
5043 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5044 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5045 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5046 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5047 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5048 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5049 return ;
5050}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5051/*
5052 * FUNCTION: WDA_ProcessSetStaKeyReq
5053 * Request to WDI for programming the STA key( key for Unicast frames
5054 * Encryption)
5055 */
5056VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5057 tSetStaKeyParams *setStaKeyParams )
5058{
5059 WDI_Status status = WDI_STATUS_SUCCESS ;
5060 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5061 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5062 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5063 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5064 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5066 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5067 if(NULL == wdiSetStaKeyParam)
5068 {
5069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5070 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5071 VOS_ASSERT(0);
5072 return VOS_STATUS_E_NOMEM;
5073 }
5074 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5075 if(NULL == pWdaParams)
5076 {
5077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5078 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5079 VOS_ASSERT(0);
5080 vos_mem_free(wdiSetStaKeyParam);
5081 return VOS_STATUS_E_NOMEM;
5082 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5083 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5084 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5085 /* copy set STA key params to WDI structure */
5086 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5087 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5088 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5089 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5090 if(setStaKeyParams->encType != eSIR_ED_NONE)
5091 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5092 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5093 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5094 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5095 {
5096 WDA_GetWepKeysFromCfg( pWDA,
5097 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5098 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5099 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5100 }
5101 else
5102 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5103 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5104 keyIndex++)
5105 {
5106 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5107 setStaKeyParams->key[keyIndex].keyId;
5108 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5109 setStaKeyParams->key[keyIndex].unicast;
5110 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5111 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5112 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5113 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5114 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5115 setStaKeyParams->key[keyIndex].paeRole;
5116 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5117 setStaKeyParams->key[keyIndex].keyLength;
5118 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5119 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5120 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5121 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5122 {
5123 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5124 }
5125 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5126 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5127 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5128 }
5129 }
5130 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5131 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5132 /* Store set key pointer, as this will be used for response */
5133 /* store Params pass it to WDI */
5134 pWdaParams->pWdaContext = pWDA;
5135 pWdaParams->wdaMsgParam = setStaKeyParams;
5136 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5137 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5138 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5139 if(IS_WDI_STATUS_FAILURE(status))
5140 {
5141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5142 "Failure in set STA Key Req WDI API, free all the memory " );
5143 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5144 vos_mem_free(pWdaParams) ;
5145 setStaKeyParams->status = eSIR_FAILURE ;
5146 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 return CONVERT_WDI2VOS_STATUS(status) ;
5149}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5150/*
5151 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5152 * send SET Bcast STA key RSP back to PE
5153 */
5154void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5155{
5156 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5157 tWDA_CbContext *pWDA;
5158 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5160 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5161 if(NULL == pWdaParams)
5162 {
5163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5164 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5165 VOS_ASSERT(0) ;
5166 return ;
5167 }
5168 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5169 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5170 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5171 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5172 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5173 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5174 return ;
5175}
5176
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5177/*
5178 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5179 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5180 * Encryption)
5181 */
5182VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5183 tSetStaKeyParams *setStaKeyParams )
5184{
5185 WDI_Status status = WDI_STATUS_SUCCESS ;
5186 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5187 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5188 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5189 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5190 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5192 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5193 if(NULL == wdiSetStaKeyParam)
5194 {
5195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5196 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5197 VOS_ASSERT(0);
5198 return VOS_STATUS_E_NOMEM;
5199 }
5200 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5201 if(NULL == pWdaParams)
5202 {
5203 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5204 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5205 VOS_ASSERT(0);
5206 vos_mem_free(wdiSetStaKeyParam);
5207 return VOS_STATUS_E_NOMEM;
5208 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5209 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5210 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5211 /* copy set STA key params to WDI structure */
5212 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5213 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5214 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5215 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5216 if(setStaKeyParams->encType != eSIR_ED_NONE)
5217 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5218 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5219 keyIndex++)
5220 {
5221 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5222 setStaKeyParams->key[keyIndex].keyId;
5223 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5224 setStaKeyParams->key[keyIndex].unicast;
5225 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5226 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5227 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5228 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5229 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5230 setStaKeyParams->key[keyIndex].paeRole;
5231 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5232 setStaKeyParams->key[keyIndex].keyLength;
5233 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5234 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5236 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5237 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5238 }
5239 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5240 /* Store set key pointer, as this will be used for response */
5241 /* store Params pass it to WDI */
5242 pWdaParams->pWdaContext = pWDA;
5243 pWdaParams->wdaMsgParam = setStaKeyParams;
5244 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5245 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5246 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5247 if(IS_WDI_STATUS_FAILURE(status))
5248 {
5249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5250 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5251 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5252 vos_mem_free(pWdaParams) ;
5253 setStaKeyParams->status = eSIR_FAILURE ;
5254 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5255 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5256 return CONVERT_WDI2VOS_STATUS(status) ;
5257}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5258/*
5259 * FUNCTION: WDA_RemoveStaKeyReqCallback
5260 * send SET BSS key RSP back to PE
5261 */
5262void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5263{
5264 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5265 tWDA_CbContext *pWDA;
5266 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5268 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5269 if(NULL == pWdaParams)
5270 {
5271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5272 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 VOS_ASSERT(0) ;
5274 return ;
5275 }
5276 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5277 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5278 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5279 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5280 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5281 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5282 return ;
5283}
5284
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5285/*
5286 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5287 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5288 */
5289VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5290 tRemoveStaKeyParams *removeStaKeyParams )
5291{
5292 WDI_Status status = WDI_STATUS_SUCCESS ;
5293 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5294 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5295 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5296 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5298 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5299 if(NULL == wdiRemoveStaKeyParam)
5300 {
5301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5302 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303 VOS_ASSERT(0);
5304 return VOS_STATUS_E_NOMEM;
5305 }
5306 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5307 if(NULL == pWdaParams)
5308 {
5309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5310 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5311 VOS_ASSERT(0);
5312 vos_mem_free(wdiRemoveStaKeyParam);
5313 return VOS_STATUS_E_NOMEM;
5314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5315 /* copy remove STA key params to WDI structure*/
5316 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5317 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5318 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5319 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5320 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5321 /* Store remove key pointer, as this will be used for response */
5322 /* store Params pass it to WDI */
5323 pWdaParams->pWdaContext = pWDA;
5324 pWdaParams->wdaMsgParam = removeStaKeyParams;
5325 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5326 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5327 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5328 if(IS_WDI_STATUS_FAILURE(status))
5329 {
5330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5331 "Failure in remove STA Key Req WDI API, free all the memory " );
5332 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5333 vos_mem_free(pWdaParams) ;
5334 removeStaKeyParams->status = eSIR_FAILURE ;
5335 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5336 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5337 return CONVERT_WDI2VOS_STATUS(status) ;
5338}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5339/*
5340 * FUNCTION: WDA_IsHandleSetLinkStateReq
5341 * Update the WDA state and return the status to handle this message or not
5342 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5343WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5344 tWDA_CbContext *pWDA,
5345 tLinkStateParams *linkStateParams)
5346{
5347 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5348 switch(linkStateParams->state)
5349 {
5350 case eSIR_LINK_PREASSOC_STATE:
5351 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5352 /*
5353 * set the WDA state to PRE ASSOC
5354 * copy the BSSID into pWDA to use it in join request and return,
5355 * No need to handle these messages.
5356 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5357 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5358 {
5359 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5360 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5361 }
5362 else
5363 {
5364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5365 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5366 VOS_ASSERT(0);
5367 }
5368
5369 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5370 {
5371 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5372 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5373 }
5374 else
5375 {
5376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5377 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5378 VOS_ASSERT(0);
5379 }
5380
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5381 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5382 *channel and after ) so reset the WDA state to ready when the second
5383 * time UMAC issue the link state with PREASSOC
5384 */
5385 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5386 {
5387 /* RESET WDA state back to WDA_READY_STATE */
5388 pWDA->wdaState = WDA_READY_STATE;
5389 }
5390 else
5391 {
5392 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5393 }
5394 //populate linkState info in WDACbCtxt
5395 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5396 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5397 default:
5398 if(pWDA->wdaState != WDA_READY_STATE)
5399 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5400 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5401 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5402 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5403 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5404 *the ASSERT in WDA_Stop during module unload.*/
5405 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5406 {
5407 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5408 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5409 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5410 else
5411 {
5412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5413 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5414 status = WDA_IGNORE_SET_LINK_STATE;
5415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5416 }
5417 break;
5418 }
5419
5420 return status;
5421}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5422/*
5423 * FUNCTION: WDA_SetLinkStateCallback
5424 * call back function for set link state from WDI
5425 */
5426void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5427{
5428 tWDA_CbContext *pWDA;
5429 tLinkStateParams *linkStateParams;
5430 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5432 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5433 if(NULL == pWdaParams)
5434 {
5435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5436 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5437 VOS_ASSERT(0) ;
5438 return ;
5439 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5440 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5441 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5442 /*
5443 * In STA mode start the BA activity check timer after association
5444 * and in AP mode start BA activity check timer after BSS start */
5445 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5446 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5447 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5448 ((status == WDI_STATUS_SUCCESS) &&
5449 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5450 {
5451 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5452 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5453 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5454 /*
5455 * No respone required for WDA_SET_LINK_STATE so free the request
5456 * param here
5457 */
5458 if( pWdaParams != NULL )
5459 {
5460 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5461 {
5462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5463 }
5464 vos_mem_free(pWdaParams);
5465 }
5466 return ;
5467}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5468/*
5469 * FUNCTION: WDA_ProcessSetLinkState
5470 * Request to WDI to set the link status.
5471 */
5472VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5473 tLinkStateParams *linkStateParams)
5474{
5475 WDI_Status status = WDI_STATUS_SUCCESS ;
5476 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5477 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5478 sizeof(WDI_SetLinkReqParamsType)) ;
5479 tWDA_ReqParams *pWdaParams ;
5480 tpAniSirGlobal pMac;
5481 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5482
5483 if(NULL == pMac)
5484 {
5485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5486 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5487 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5488 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5489 return VOS_STATUS_E_FAILURE;
5490 }
5491
5492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5493 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5494 if(NULL == wdiSetLinkStateParam)
5495 {
5496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5497 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5498 VOS_ASSERT(0);
5499 return VOS_STATUS_E_NOMEM;
5500 }
5501 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5502 if(NULL == pWdaParams)
5503 {
5504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5505 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5506 VOS_ASSERT(0);
5507 vos_mem_free(wdiSetLinkStateParam);
5508 return VOS_STATUS_E_NOMEM;
5509 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5510 if(WDA_IGNORE_SET_LINK_STATE ==
5511 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5512 {
5513 status = WDI_STATUS_E_FAILURE;
5514 }
5515 else
5516 {
5517 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5518 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5519 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5520 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5521 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5522 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5523 pWdaParams->pWdaContext = pWDA;
5524 /* Store remove key pointer, as this will be used for response */
5525 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5526 /* store Params pass it to WDI */
5527 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5528 /* Stop Timer only other than GO role and concurrent session */
5529 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5530 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5531 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5532 {
5533 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5534 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5535 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5536 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5537 if(IS_WDI_STATUS_FAILURE(status))
5538 {
5539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5540 "Failure in set link state Req WDI API, free all the memory " );
5541 }
5542 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5543 if(IS_WDI_STATUS_FAILURE(status))
5544 {
5545 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5546 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5547 vos_mem_free(pWdaParams);
5548 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5549 return CONVERT_WDI2VOS_STATUS(status) ;
5550}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5551/*
5552 * FUNCTION: WDA_GetStatsReqParamsCallback
5553 * send the response to PE with Stats received from WDI
5554 */
5555void WDA_GetStatsReqParamsCallback(
5556 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5557 void* pUserData)
5558{
5559 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5560 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5561
5562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5563 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5564 pGetPEStatsRspParams =
5565 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5566 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5567
5568 if(NULL == pGetPEStatsRspParams)
5569 {
5570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5571 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5572 VOS_ASSERT(0);
5573 return;
5574 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5575 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5576 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5577 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5578 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5579
5580 //Fill the Session Id Properly in PE
5581 pGetPEStatsRspParams->sessionId = 0;
5582 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5583 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5584 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5585 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5586 vos_mem_copy( pGetPEStatsRspParams + 1,
5587 wdiGetStatsRsp + 1,
5588 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5589 /* send response to UMAC*/
5590 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5591
5592 return;
5593}
5594
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5595/*
5596 * FUNCTION: WDA_ProcessGetStatsReq
5597 * Request to WDI to get the statistics
5598 */
5599VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5600 tAniGetPEStatsReq *pGetStatsParams)
5601{
5602 WDI_Status status = WDI_STATUS_SUCCESS ;
5603 WDI_GetStatsReqParamsType wdiGetStatsParam;
5604 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5606 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5607 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5608 pGetStatsParams->staId;
5609 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5610 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5611 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5612 status = WDI_GetStatsReq(&wdiGetStatsParam,
5613 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5614 if(IS_WDI_STATUS_FAILURE(status))
5615 {
5616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5617 "Failure in Get Stats Req WDI API, free all the memory " );
5618 pGetPEStatsRspParams =
5619 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5620 if(NULL == pGetPEStatsRspParams)
5621 {
5622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5623 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5624 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5625 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5626 return VOS_STATUS_E_NOMEM;
5627 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5628 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5629 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5630 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5631 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5632 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5633 (void *)pGetPEStatsRspParams, 0) ;
5634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5635 /* Free the request message */
5636 vos_mem_free(pGetStatsParams);
5637 return CONVERT_WDI2VOS_STATUS(status);
5638}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5639
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5640#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5641/*
5642 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5643 * send the response to PE with roam Rssi received from WDI
5644 */
5645void WDA_GetRoamRssiReqParamsCallback(
5646 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5647 void* pUserData)
5648{
5649 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5650 tWDA_CbContext *pWDA = NULL;
5651 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5652 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5654 "<------ %s " ,__func__);
5655 if(NULL == pWdaParams)
5656 {
5657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5658 "%s: pWdaParams received NULL", __func__);
5659 VOS_ASSERT(0) ;
5660 return ;
5661 }
5662 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5663 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5664
5665 if(NULL == pGetRoamRssiReqParams)
5666 {
5667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5668 "%s: pGetRoamRssiReqParams received NULL", __func__);
5669 VOS_ASSERT(0);
5670 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5671 vos_mem_free(pWdaParams);
5672 return ;
5673 }
5674 pGetRoamRssiRspParams =
5675 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5676
5677 if(NULL == pGetRoamRssiRspParams)
5678 {
5679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5680 "%s: VOS MEM Alloc Failure", __func__);
5681 VOS_ASSERT(0);
5682 return;
5683 }
5684 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5685 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5686 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5687 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5688 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5689
5690 /* Assign get roam rssi req (backup) in to the response */
5691 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5692
5693 /* free WDI command buffer */
5694 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5695 vos_mem_free(pWdaParams) ;
5696
5697 /* send response to UMAC*/
5698 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5699
5700 return;
5701}
5702
5703
5704
5705/*
5706 * FUNCTION: WDA_ProcessGetRoamRssiReq
5707 * Request to WDI to get the statistics
5708 */
5709VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5710 tAniGetRssiReq *pGetRoamRssiParams)
5711{
5712 WDI_Status status = WDI_STATUS_SUCCESS ;
5713 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5714 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5715 tWDA_ReqParams *pWdaParams = NULL;
5716
5717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5718 "------> %s " ,__func__);
5719 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5720 pGetRoamRssiParams->staId;
5721 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5722
5723 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5724 if(NULL == pWdaParams)
5725 {
5726 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5727 "%s: VOS MEM Alloc Failure", __func__);
5728 VOS_ASSERT(0);
5729 return VOS_STATUS_E_NOMEM;
5730 }
5731
5732 /* Store Init Req pointer, as this will be used for response */
5733 pWdaParams->pWdaContext = pWDA;
5734
5735 /* Take Get roam Rssi req backup as it stores the callback to be called after
5736 receiving the response */
5737 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5738 pWdaParams->wdaWdiApiMsgParam = NULL;
5739
5740 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5741 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5742 if(IS_WDI_STATUS_FAILURE(status))
5743 {
5744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5745 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5746 pGetRoamRssiRspParams =
5747 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5748 if(NULL == pGetRoamRssiRspParams)
5749 {
5750 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5751 "%s: VOS MEM Alloc Failure", __func__);
5752 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5753 vos_mem_free(pGetRoamRssiParams);
5754 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5755 return VOS_STATUS_E_NOMEM;
5756 }
5757 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5758 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5759 pGetRoamRssiRspParams->rssi = 0;
5760 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5761 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5762 (void *)pGetRoamRssiRspParams, 0) ;
5763 }
5764 return CONVERT_WDI2VOS_STATUS(status);
5765}
5766#endif
5767
5768
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5769/*
5770 * FUNCTION: WDA_UpdateEDCAParamCallback
5771 * call back function for Update EDCA params from WDI
5772 */
5773void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5774{
5775 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5776 tEdcaParams *pEdcaParams;
5777
5778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5779 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5780 if(NULL == pWdaParams)
5781 {
5782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5783 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5784 VOS_ASSERT(0) ;
5785 return ;
5786 }
5787 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5788 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5789 vos_mem_free(pWdaParams);
5790 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5791 return ;
5792}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5793/*
5794 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5795 * Request to WDI to Update the EDCA params.
5796 */
5797VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5798 tEdcaParams *pEdcaParams)
5799{
5800 WDI_Status status = WDI_STATUS_SUCCESS ;
5801 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5802 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5803 sizeof(WDI_UpdateEDCAParamsType)) ;
5804 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5806 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5807 if(NULL == wdiEdcaParam)
5808 {
5809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5810 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5811 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5812 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5813 return VOS_STATUS_E_NOMEM;
5814 }
5815 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5816 if(NULL == pWdaParams)
5817 {
5818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5819 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5820 VOS_ASSERT(0);
5821 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5822 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5823 return VOS_STATUS_E_NOMEM;
5824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5825 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5826 /*
5827 Since firmware is not using highperformance flag, we have removed
5828 this flag from wdiEDCAInfo structure to match sizeof the structure
5829 between host and firmware.In future if we are planning to use
5830 highperformance flag then Please define this flag in wdiEDCAInfo
5831 structure, update it here and send it to firmware. i.e.
5832 Following is the original line which we removed as part of the fix
5833 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5834 pEdcaParams->highPerformance;
5835 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5836 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5837 &pEdcaParams->acbe);
5838 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5839 &pEdcaParams->acbk);
5840 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5841 &pEdcaParams->acvi);
5842 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5843 &pEdcaParams->acvo);
5844 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5845 pWdaParams->pWdaContext = pWDA;
5846 /* Store remove key pointer, as this will be used for response */
5847 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5848 /* store Params pass it to WDI */
5849 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5850 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5851 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5852 if(IS_WDI_STATUS_FAILURE(status))
5853 {
5854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5855 "Failure in Update EDCA Params WDI API, free all the memory " );
5856 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5857 vos_mem_free(pWdaParams);
5858 vos_mem_free(pEdcaParams);
5859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5860 return CONVERT_WDI2VOS_STATUS(status) ;
5861}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5862/*
5863 * FUNCTION: WDA_AddBAReqCallback
5864 * send ADD BA RSP back to PE
5865 */
5866void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5867 void* pUserData)
5868{
5869 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5870 tWDA_CbContext *pWDA;
5871 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5873 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5874 if(NULL == pWdaParams)
5875 {
5876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5877 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5878 VOS_ASSERT(0) ;
5879 return ;
5880 }
5881 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5882 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5883 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5884 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5885 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5886 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5887 return ;
5888}
5889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5890/*
5891 * FUNCTION: WDA_ProcessAddBAReq
5892 * Request to WDI to Update the ADDBA REQ params.
5893 */
5894VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5895 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5896{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5897 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5898 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5899 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5900 sizeof(WDI_AddBAReqParamsType)) ;
5901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5904 if(NULL == wdiAddBAReqParam)
5905 {
5906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5908 VOS_ASSERT(0);
5909 return VOS_STATUS_E_NOMEM;
5910 }
5911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5912 if(NULL == pWdaParams)
5913 {
5914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 VOS_ASSERT(0);
5917 vos_mem_free(wdiAddBAReqParam);
5918 return VOS_STATUS_E_NOMEM;
5919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5920 do
5921 {
5922 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5923 wdiAddBaInfo->ucSTAIdx = staIdx ;
5924 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5925 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5926 } while(0) ;
5927 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5928 pWdaParams->pWdaContext = pWDA;
5929 /* store Params pass it to WDI */
5930 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5931 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5932 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5933 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5934
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5935 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5936 {
5937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5938 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5939 status = CONVERT_WDI2VOS_STATUS(wstatus);
5940 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5941 vos_mem_free(pWdaParams);
5942 pAddBAReqParams->status = eSIR_FAILURE;
5943 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5944 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5945 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5947/*
5948 * FUNCTION: WDA_AddBASessionReqCallback
5949 * send ADD BA SESSION RSP back to PE/(or TL)
5950 */
5951void WDA_AddBASessionReqCallback(
5952 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
5953{
5954 VOS_STATUS status = VOS_STATUS_SUCCESS ;
5955 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5956 tWDA_CbContext *pWDA;
5957 tAddBAParams *pAddBAReqParams ;
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 == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5964 VOS_ASSERT(0) ;
5965 return ;
5966 }
5967 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5968 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5969 if( NULL == pAddBAReqParams )
5970 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5972 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5973 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5975 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5976 return ;
5977 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5979 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5980 /*
5981 * if WDA in update TL state, update TL with BA session parama and send
5982 * another request to HAL(/WDI) (ADD_BA_REQ)
5983 */
5984
5985 if((VOS_STATUS_SUCCESS ==
5986 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
5987 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
5988 {
5989 /* Update TL with BA info received from HAL/WDI */
5990 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
5991 wdiAddBaSession->usBaSessionID,
5992 wdiAddBaSession->ucSTAIdx,
5993 wdiAddBaSession->ucBaTID,
5994 wdiAddBaSession->ucBaBufferSize,
5995 wdiAddBaSession->ucWinSize,
5996 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5997 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
5998 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
5999 }
6000 else
6001 {
6002 pAddBAReqParams->status =
6003 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6004
6005 /* Setting Flag to indicate that Set BA is success */
6006 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6007 {
6008 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6009 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6010 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6011 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6012 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6013 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6014 /*Reset the WDA state to READY */
6015 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6016 return ;
6017}
6018
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6019/*
6020 * FUNCTION: WDA_ProcessAddBASessionReq
6021 * Request to WDI to Update the ADDBA REQ params.
6022 */
6023VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6024 tAddBAParams *pAddBAReqParams)
6025{
6026 WDI_Status status = WDI_STATUS_SUCCESS ;
6027 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6028 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6029 sizeof(WDI_AddBASessionReqParamsType)) ;
6030 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6031 WLANTL_STAStateType tlSTAState = 0;
6032
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6034 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6035 if(NULL == wdiAddBASessionReqParam)
6036 {
6037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6038 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6039 VOS_ASSERT(0);
6040 return VOS_STATUS_E_NOMEM;
6041 }
6042 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6043 if(NULL == pWdaParams)
6044 {
6045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6047 VOS_ASSERT(0);
6048 vos_mem_free(wdiAddBASessionReqParam);
6049 return VOS_STATUS_E_NOMEM;
6050 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6051 /*
6052 * Populate ADD BA parameters and pass these paarmeters to WDI.
6053 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6054 * the state to track if these is BA recipient case or BA initiator
6055 * case.
6056 */
6057 do
6058 {
6059 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6060 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6061 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6062 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6063 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6064 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6065 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6066 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6067 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6068 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6069 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6070 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6071 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072 /* check the BA direction and update state accordingly */
6073 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
6074 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
6075 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
6076
6077 }while(0) ;
6078 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6079 pWdaParams->pWdaContext = pWDA;
6080 /* Store ADD BA pointer, as this will be used for response */
6081 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6082 /* store Params pass it to WDI */
6083 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6084
6085 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6086 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6087 */
6088 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6089 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6090 {
6091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6092 "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]6093 status = WDI_STATUS_E_NOT_ALLOWED;
6094 pAddBAReqParams->status =
6095 CONVERT_WDI2SIR_STATUS(status) ;
6096 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6097 /*Reset the WDA state to READY */
6098 pWDA->wdaState = WDA_READY_STATE;
6099 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6100 vos_mem_free(pWdaParams);
6101
6102 return CONVERT_WDI2VOS_STATUS(status) ;
6103 }
6104
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6105 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6106 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6107 if(IS_WDI_STATUS_FAILURE(status))
6108 {
6109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6110 "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]6111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6112 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6113 pAddBAReqParams->status =
6114 CONVERT_WDI2SIR_STATUS(status) ;
6115 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6116 /*Reset the WDA state to READY */
6117 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6118 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6119 vos_mem_free(pWdaParams);
6120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6121 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6122}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6123/*
6124 * FUNCTION: WDA_DelBANotifyTL
6125 * send DEL BA IND to TL
6126 */
6127void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6128 tDelBAParams *pDelBAReqParams)
6129{
6130 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6131 //tSirMsgQ msg;
6132 vos_msg_t vosMsg;
6133 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6134 if(NULL == pDelBAInd)
6135 {
6136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6137 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6138 VOS_ASSERT(0) ;
6139 return;
6140 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6141 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6142 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6143 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6144 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6146
6147 vosMsg.type = WDA_DELETEBA_IND;
6148 vosMsg.bodyptr = pDelBAInd;
6149 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6150 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6151 {
6152 vosStatus = VOS_STATUS_E_BADMSG;
6153 }
6154}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6155/*
6156 * FUNCTION: WDA_DelBAReqCallback
6157 * send DEL BA RSP back to PE
6158 */
6159void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6160{
6161 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6162 tWDA_CbContext *pWDA;
6163 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6165 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6166 if(NULL == pWdaParams)
6167 {
6168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6169 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6170 VOS_ASSERT(0) ;
6171 return ;
6172 }
6173 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6174 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6175 /* Notify TL about DEL BA in case of recipinet */
6176 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6177 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6178 {
6179 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6181 /*
6182 * No respone required for WDA_DELBA_IND so just free the request
6183 * param here
6184 */
6185 vos_mem_free(pDelBAReqParams);
6186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6187 vos_mem_free(pWdaParams);
6188 return ;
6189}
6190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6191/*
6192 * FUNCTION: WDA_ProcessDelBAReq
6193 * Request to WDI to Update the DELBA REQ params.
6194 */
6195VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6196 tDelBAParams *pDelBAReqParams)
6197{
6198 WDI_Status status = WDI_STATUS_SUCCESS ;
6199 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6200 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6201 sizeof(WDI_DelBAReqParamsType)) ;
6202 tWDA_ReqParams *pWdaParams ;
6203 tANI_U16 staIdx = 0;
6204 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6206 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6207 if(NULL == wdiDelBAReqParam)
6208 {
6209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6210 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6211 VOS_ASSERT(0);
6212 return VOS_STATUS_E_NOMEM;
6213 }
6214 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6215 if(NULL == pWdaParams)
6216 {
6217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6218 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6219 VOS_ASSERT(0);
6220 vos_mem_free(wdiDelBAReqParam);
6221 return VOS_STATUS_E_NOMEM;
6222 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6223 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6224 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6225 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6226 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6227 pWdaParams->pWdaContext = pWDA;
6228 /* Store DEL BA pointer, as this will be used for response */
6229 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6230 /* store Params pass it to WDI */
6231 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6232 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6233 * maintained in WDA, so that WDA can retry for another BA session
6234 */
6235 staIdx = pDelBAReqParams->staIdx;
6236 tid = pDelBAReqParams->baTID;
6237 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6238 status = WDI_DelBAReq(wdiDelBAReqParam,
6239 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6240 if(IS_WDI_STATUS_FAILURE(status))
6241 {
6242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6243 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6244 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6245 vos_mem_free(pWdaParams->wdaMsgParam);
6246 vos_mem_free(pWdaParams);
6247 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6248 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6249}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6250
6251/*
6252 * FUNCTION: WDA_UpdateChReqCallback
6253 *
6254 */
6255void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6256{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6257 tWDA_ReqParams *pWdaParams;
6258 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6259 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6260 WDI_UpdateChannelReqinfoType *pChanInfoType;
6261 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6262
6263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6264 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6265 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6266 {
6267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6268 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6269 VOS_ASSERT(0);
6270 return;
6271 }
6272
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6273 pWdaParams = (tWDA_ReqParams *)pUserData;
6274 pwdiUpdateChReqParam =
6275 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6276 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6277 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6278 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6279 /*
6280 * currently there is no response message is expected between PE and
6281 * WDA, Failure return from WDI is a ASSERT condition
6282 */
6283 vos_mem_free(pChanInfoType);
6284 vos_mem_free(pChanList);
6285 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6286 vos_mem_free(pWdaParams);
6287
6288 return;
6289}
6290
6291/*
6292 * FUNCTION: WDA_ProcessUpdateChannelList
6293 * Request to WDI to Update the ChannelList params.
6294 */
6295VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6296 tSirUpdateChanList *pChanList)
6297{
6298 WDI_Status status = WDI_STATUS_SUCCESS;
6299 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6300 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6301 WDI_UpdateChannelReqinfoType *pChanInfoType;
6302 tWDA_ReqParams *pWdaParams;
6303 wpt_uint8 i;
6304
6305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6306 "------> %s " ,__func__);
6307 if(NULL == pChanList)
6308 {
6309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6310 "%s: NULL pChanList", __func__);
6311 VOS_ASSERT(0);
6312 return VOS_STATUS_E_INVAL;
6313 }
6314
6315 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6316 {
6317 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6318 "Update channel list capability Not Supported");
6319 vos_mem_free(pChanList);
6320 return VOS_STATUS_E_INVAL;
6321 }
6322
6323 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6324 sizeof(WDI_UpdateChReqParamsType));
6325 if(NULL == pwdiUpdateChReqParam)
6326 {
6327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6328 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6329 __func__);
6330 VOS_ASSERT(0);
6331 vos_mem_free(pChanList);
6332 return VOS_STATUS_E_NOMEM;
6333 }
6334 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6335 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6336 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6337 pChanList->numChan);
6338 if(NULL == pChanInfoType)
6339 {
6340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6341 "%s: VOS MEM Alloc Failure", __func__);
6342 VOS_ASSERT(0);
6343 vos_mem_free(pChanList);
6344 vos_mem_free(pwdiUpdateChReqParam);
6345 return VOS_STATUS_E_NOMEM;
6346 }
6347 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6348 * pChanList->numChan);
6349 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6350
6351 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6352 if(NULL == pWdaParams)
6353 {
6354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6355 "%s: VOS MEM Alloc Failure", __func__);
6356 VOS_ASSERT(0);
6357 vos_mem_free(pChanList);
6358 vos_mem_free(pChanInfoType);
6359 vos_mem_free(pwdiUpdateChReqParam);
6360 return VOS_STATUS_E_NOMEM;
6361 }
6362 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6363
6364 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6365 {
6366 pChanInfoType->mhz =
6367 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6368
6369 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6370 pChanInfoType->band_center_freq2 = 0;
6371
6372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6373 "chan[%d] = %u", i, pChanInfoType->mhz);
6374 if (pChanList->chanParam[i].dfsSet)
6375 {
6376 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6378 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6379 pChanList->chanParam[i].dfsSet);
6380 }
6381
6382 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6383 {
6384 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6385 }
6386 else
6387 {
6388 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6389 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6390 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6391 }
6392
6393 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6394 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6395
6396 pChanInfoType++;
6397 }
6398
6399 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6400 pWdaParams->pWdaContext = pWDA;
6401 pWdaParams->wdaMsgParam = (void *)pChanList;
6402 /* store Params pass it to WDI */
6403 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6404 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6405 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6406 if(IS_WDI_STATUS_FAILURE(status))
6407 {
6408 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6409 "Failure in Update Channel REQ Params WDI API, free all the memory");
6410 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6411 vos_mem_free(pwdiUpdateChReqParam);
6412 vos_mem_free(pWdaParams->wdaMsgParam);
6413 vos_mem_free(pWdaParams);
6414 }
6415 return CONVERT_WDI2VOS_STATUS(status);
6416}
6417
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6418/*
6419 * FUNCTION: WDA_AddTSReqCallback
6420 * send ADD TS RSP back to PE
6421 */
6422void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6423{
6424 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6425 tWDA_CbContext *pWDA;
6426 tAddTsParams *pAddTsReqParams;
6427
6428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6429 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6430 if(NULL == pWdaParams)
6431 {
6432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6433 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6434 VOS_ASSERT(0) ;
6435 return ;
6436 }
6437 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6438 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6439 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6440 vos_mem_free(pWdaParams);
6441
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6442 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6443 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6444 return ;
6445}
6446
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6447/*
6448 * FUNCTION: WDA_ProcessAddTSReq
6449 * Request to WDI to Update the ADD TS REQ params.
6450 */
6451VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6452 tAddTsParams *pAddTsReqParams)
6453{
6454 WDI_Status status = WDI_STATUS_SUCCESS ;
6455 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6456 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6457 sizeof(WDI_AddTSReqParamsType)) ;
6458 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6460 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6461 if(NULL == wdiAddTSReqParam)
6462 {
6463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6464 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6465 VOS_ASSERT(0);
6466 return VOS_STATUS_E_NOMEM;
6467 }
6468 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6469 if(NULL == pWdaParams)
6470 {
6471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6472 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6473 VOS_ASSERT(0);
6474 vos_mem_free(wdiAddTSReqParam);
6475 return VOS_STATUS_E_NOMEM;
6476 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6477 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6478 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6479 //TS IE
6480 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6481 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6482 pAddTsReqParams->tspec.length;
6483
6484 //TS IE : TS INFO : TRAFFIC
6485 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6486 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6487 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6488 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6489 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6490 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6491 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6492 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6493 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6494 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6495 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6496 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6497 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6498 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6499 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6500 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6501
6502 //TS IE : TS INFO : SCHEDULE
6503 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6504 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6505 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6506 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6507 //TS IE
6508 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6509 pAddTsReqParams->tspec.nomMsduSz;
6510 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6511 pAddTsReqParams->tspec.maxMsduSz;
6512 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6513 pAddTsReqParams->tspec.minSvcInterval;
6514 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6515 pAddTsReqParams->tspec.maxSvcInterval;
6516 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6517 pAddTsReqParams->tspec.inactInterval;
6518 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6519 pAddTsReqParams->tspec.suspendInterval;
6520 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6521 pAddTsReqParams->tspec.svcStartTime;
6522 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6523 pAddTsReqParams->tspec.minDataRate;
6524 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6525 pAddTsReqParams->tspec.meanDataRate;
6526 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6527 pAddTsReqParams->tspec.peakDataRate;
6528 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6529 pAddTsReqParams->tspec.maxBurstSz;
6530 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6531 pAddTsReqParams->tspec.delayBound;
6532 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6533 pAddTsReqParams->tspec.minPhyRate;
6534 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6535 pAddTsReqParams->tspec.surplusBw;
6536 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6537 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6538 /* TODO: tAddTsParams doesn't have the following fields */
6539#if 0
6540 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6541 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6542 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6543 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6544#endif
6545 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6546
6547 pWdaParams->pWdaContext = pWDA;
6548 /* Store ADD TS pointer, as this will be used for response */
6549 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6550 /* store Params pass it to WDI */
6551 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6552 status = WDI_AddTSReq(wdiAddTSReqParam,
6553 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6554 if(IS_WDI_STATUS_FAILURE(status))
6555 {
6556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6557 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6558 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6559 vos_mem_free(pWdaParams);
6560 pAddTsReqParams->status = eSIR_FAILURE ;
6561 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6562 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6563 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6564}
6565
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6566/*
6567 * FUNCTION: WDA_DelTSReqCallback
6568 * send DEL TS RSP back to PE
6569 */
6570void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6571{
6572 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6574 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6575 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6576 vos_mem_free(pWdaParams->wdaMsgParam) ;
6577 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6578 /*
6579 * No respone required for WDA_DEL_TS_REQ so just free the request
6580 * param here
6581 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6582 return ;
6583}
6584
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6585/*
6586 * FUNCTION: WDA_ProcessDelTSReq
6587 * Request to WDI to Update the DELTS REQ params.
6588 */
6589VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6590 tDelTsParams *pDelTSReqParams)
6591{
6592 WDI_Status status = WDI_STATUS_SUCCESS ;
6593 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6594 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6595 sizeof(WDI_DelTSReqParamsType)) ;
6596 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6598 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6599 if(NULL == wdiDelTSReqParam)
6600 {
6601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6602 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6603 VOS_ASSERT(0);
6604 return VOS_STATUS_E_NOMEM;
6605 }
6606 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6607 if(NULL == pWdaParams)
6608 {
6609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6610 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6611 VOS_ASSERT(0);
6612 vos_mem_free(wdiDelTSReqParam);
6613 return VOS_STATUS_E_NOMEM;
6614 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6615 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6616 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6617 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6618 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6619 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6620 pWdaParams->pWdaContext = pWDA;
6621 /* Store DEL TS pointer, as this will be used for response */
6622 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6623 /* store Params pass it to WDI */
6624 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6625 status = WDI_DelTSReq(wdiDelTSReqParam,
6626 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6627 if(IS_WDI_STATUS_FAILURE(status))
6628 {
6629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6630 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6631 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6632 vos_mem_free(pWdaParams->wdaMsgParam);
6633 vos_mem_free(pWdaParams);
6634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6635 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6636}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6637/*
6638 * FUNCTION: WDA_UpdateBeaconParamsCallback
6639 * Free the memory. No need to send any response to PE in this case
6640 */
6641void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6642{
6643 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6645 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6646 if(NULL == pWdaParams)
6647 {
6648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6649 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6650 VOS_ASSERT(0) ;
6651 return ;
6652 }
6653 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6654 vos_mem_free(pWdaParams->wdaMsgParam) ;
6655 vos_mem_free(pWdaParams);
6656 /*
6657 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6658 * param here
6659 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6660 return ;
6661}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6662/*
6663 * FUNCTION: WDA_ProcessUpdateBeaconParams
6664 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6665 */
6666VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6667 tUpdateBeaconParams *pUpdateBeaconParams)
6668{
6669 WDI_Status status = WDI_STATUS_SUCCESS ;
6670 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6671 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6672 sizeof(WDI_UpdateBeaconParamsType)) ;
6673 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6675 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6676 if(NULL == wdiUpdateBeaconParams)
6677 {
6678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6679 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6680 VOS_ASSERT(0);
6681 return VOS_STATUS_E_NOMEM;
6682 }
6683 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6684 if(NULL == pWdaParams)
6685 {
6686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6687 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6688 VOS_ASSERT(0);
6689 vos_mem_free(wdiUpdateBeaconParams);
6690 return VOS_STATUS_E_NOMEM;
6691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6692 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6693 pUpdateBeaconParams->bssIdx;
6694 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6695 pUpdateBeaconParams->fShortPreamble;
6696 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6697 pUpdateBeaconParams->fShortSlotTime;
6698 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6699 pUpdateBeaconParams->beaconInterval;
6700 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6701 pUpdateBeaconParams->llaCoexist;
6702 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6703 pUpdateBeaconParams->llbCoexist;
6704 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6705 pUpdateBeaconParams->llgCoexist;
6706 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6707 pUpdateBeaconParams->ht20MhzCoexist;
6708 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6709 pUpdateBeaconParams->llnNonGFCoexist;
6710 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6711 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6712 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6713 pUpdateBeaconParams->fRIFSMode;
6714 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6715 pUpdateBeaconParams->paramChangeBitmap;
6716 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6717
6718 pWdaParams->pWdaContext = pWDA;
6719 /* Store UpdateBeacon Req pointer, as this will be used for response */
6720 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6721 /* store Params pass it to WDI */
6722 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6723 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6724 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6725 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6726 if(IS_WDI_STATUS_FAILURE(status))
6727 {
6728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6729 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6730 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6731 vos_mem_free(pWdaParams->wdaMsgParam);
6732 vos_mem_free(pWdaParams);
6733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6734 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6735}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6736#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6737/*
6738 * FUNCTION: WDA_TSMStatsReqCallback
6739 * send TSM Stats RSP back to PE
6740 */
6741void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6742{
6743 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6744 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6745 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6746 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6747
6748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6749 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6750 if(NULL == pWdaParams)
6751 {
6752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6753 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6754 VOS_ASSERT(0) ;
6755 return ;
6756 }
6757 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6758 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6759
6760 if(NULL == pGetTsmStatsReqParams)
6761 {
6762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6763 "%s: pGetTsmStatsReqParams received NULL", __func__);
6764 VOS_ASSERT(0);
6765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6766 vos_mem_free(pWdaParams);
6767 return;
6768 }
6769
6770 pTsmRspParams =
6771 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6772 if( NULL == pTsmRspParams )
6773 {
6774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6775 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 VOS_ASSERT( 0 );
6777 return ;
6778 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6779 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6780 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6781 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6783 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6784 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6785 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6786 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6787 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6788 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6789 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6790 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6791 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6792 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6793
6794 /* Assign get tsm stats req req (backup) in to the response */
6795 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6796
6797 /* free WDI command buffer */
6798 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6799 vos_mem_free(pWdaParams);
6800
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6801 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6802 return ;
6803}
6804
6805
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6806/*
6807 * FUNCTION: WDA_ProcessTsmStatsReq
6808 * Request to WDI to get the TSM Stats params.
6809 */
6810VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6811 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6812{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6813 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6814 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6815 tWDA_ReqParams *pWdaParams = NULL;
6816 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6817
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6819 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6820 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6821 sizeof(WDI_TSMStatsReqParamsType));
6822 if(NULL == wdiTSMReqParam)
6823 {
6824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6825 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6826 VOS_ASSERT(0);
6827 return VOS_STATUS_E_NOMEM;
6828 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6829 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6830 if(NULL == pWdaParams)
6831 {
6832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6833 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6834 VOS_ASSERT(0);
6835 vos_mem_free(wdiTSMReqParam);
6836 return VOS_STATUS_E_NOMEM;
6837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6838 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6839 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6840 pTsmStats->bssId,
6841 sizeof(wpt_macAddr));
6842 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6843
6844 pWdaParams->pWdaContext = pWDA;
6845 /* Store TSM Stats pointer, as this will be used for response */
6846 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6847 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6848 status = WDI_TSMStatsReq(wdiTSMReqParam,
6849 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6850 if(IS_WDI_STATUS_FAILURE(status))
6851 {
6852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6853 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6854 vos_mem_free(pWdaParams);
6855
6856 pGetTsmStatsRspParams =
6857 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6858 if(NULL == pGetTsmStatsRspParams)
6859 {
6860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6861 "%s: VOS MEM Alloc Failure", __func__);
6862 VOS_ASSERT(0);
6863 vos_mem_free(pTsmStats);
6864 return VOS_STATUS_E_NOMEM;
6865 }
6866 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6867 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6868 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6869
6870 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6871 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6872 return CONVERT_WDI2VOS_STATUS(status) ;
6873}
6874#endif
6875/*
6876 * FUNCTION: WDA_SendBeaconParamsCallback
6877 * No need to send any response to PE in this case
6878 */
6879void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6880{
6881
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6883 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884 return ;
6885}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6886/*
6887 * FUNCTION: WDA_ProcessSendBeacon
6888 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6889 * start beacon trasmission
6890 */
6891VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6892 tSendbeaconParams *pSendbeaconParams)
6893{
6894 WDI_Status status = WDI_STATUS_SUCCESS ;
6895 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6897 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6898 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6899 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6900 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6901 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6902 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6903 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6904 /* p2pIeOffset should be atleast greater than timIeOffset */
6905 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6906 (pSendbeaconParams->p2pIeOffset <
6907 pSendbeaconParams->timIeOffset))
6908 {
6909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6910 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6911 VOS_ASSERT( 0 );
6912 return WDI_STATUS_E_FAILURE;
6913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6914 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6915 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6916 /* Copy the beacon template to local buffer */
6917 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6918 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6919 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6920
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6921 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6922 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6923 if(IS_WDI_STATUS_FAILURE(status))
6924 {
6925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6926 "Failure in SEND BEACON REQ Params WDI API" );
6927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6928 vos_mem_free(pSendbeaconParams);
6929 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6930}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6931/*
6932 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6933 * No need to send any response to PE in this case
6934 */
6935void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6936{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6938 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6939 return ;
6940}
6941
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6942/*
6943 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6944 * Request to WDI to send the probe response template to HAL to update the TPE memory and
6945 * send probe response
6946 */
6947VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
6948 tSendProbeRespParams *pSendProbeRspParams)
6949{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6950 WDI_Status status = WDI_STATUS_SUCCESS;
6951 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
6952 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6954 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6955
6956 if (!wdiSendProbeRspParam)
6957 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
6958
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6959 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6960 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6961 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6962 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6963 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6964 /* Copy the Probe Response template to local buffer */
6965 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6966 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6967 pSendProbeRspParams->pProbeRespTemplate,
6968 pSendProbeRspParams->probeRespTemplateLen);
6969 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6970 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6971 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
6972 WDI_PROBE_REQ_BITMAP_IE_LEN);
6973
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6974 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6975
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6976 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6977 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6978 if(IS_WDI_STATUS_FAILURE(status))
6979 {
6980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6981 "Failure in SEND Probe RSP Params WDI API" );
6982 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6983 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6984 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6985 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6986}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6987#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6988/*
6989 * FUNCTION: WDA_SetMaxTxPowerCallBack
6990 * send the response to PE with power value received from WDI
6991 */
6992void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
6993 void* pUserData)
6994{
6995 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6996 tWDA_CbContext *pWDA = NULL;
6997 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
6998
6999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7000 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7001 if(NULL == pWdaParams)
7002 {
7003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7004 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7005 VOS_ASSERT(0) ;
7006 return ;
7007 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7008 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7009 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7010 if( NULL == pMaxTxPowerParams )
7011 {
7012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7013 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7014 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7015 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7016 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7017 return ;
7018 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7019
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7020
7021 /*need to free memory for the pointers used in the
7022 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7023 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7024 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7025 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7026
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7027
7028 /* send response to UMAC*/
7029 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7030
7031 return;
7032}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7033/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7034 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7035 * Request to WDI to send set Max Tx Power Request
7036 */
7037 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7038 tMaxTxPowerParams *MaxTxPowerParams)
7039{
7040 WDI_Status status = WDI_STATUS_SUCCESS;
7041 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7042 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7043
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7045 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7046
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7047 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7048 sizeof(WDI_SetMaxTxPowerParamsType));
7049 if(NULL == wdiSetMaxTxPowerParams)
7050 {
7051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7052 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7053 VOS_ASSERT(0);
7054 return VOS_STATUS_E_NOMEM;
7055 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7056 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7061 vos_mem_free(wdiSetMaxTxPowerParams);
7062 VOS_ASSERT(0);
7063 return VOS_STATUS_E_NOMEM;
7064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7065 /* Copy.Max.Tx.Power Params to WDI structure */
7066 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7067 MaxTxPowerParams->bssId,
7068 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7069 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7070 MaxTxPowerParams->selfStaMacAddr,
7071 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7072 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7073 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7074 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7075 pWdaParams->pWdaContext = pWDA;
7076 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7077 /* store Params pass it to WDI */
7078 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7079 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7080 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7081 if(IS_WDI_STATUS_FAILURE(status))
7082 {
7083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7084 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7085 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7086 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7087 /* send response to UMAC*/
7088 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7089 }
7090 return CONVERT_WDI2VOS_STATUS(status);
7091
7092}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7093#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7094
7095/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7096 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7097 * send the response to PE with power value received from WDI
7098 */
7099void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7100 *pwdiSetMaxTxPowerPerBandRsp,
7101 void* pUserData)
7102{
7103 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7104 tWDA_CbContext *pWDA = NULL;
7105 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7106
7107 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7108 "<------ %s ", __func__);
7109 if (NULL == pWdaParams)
7110 {
7111 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7112 "%s: pWdaParams received NULL", __func__);
7113 VOS_ASSERT(0);
7114 return ;
7115 }
7116 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7117 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7118 if ( NULL == pMxTxPwrPerBandParams )
7119 {
7120 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7121 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7122 VOS_ASSERT(0);
7123 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7124 vos_mem_free(pWdaParams);
7125 return;
7126 }
7127
7128 /*need to free memory for the pointers used in the
7129 WDA Process.Set Max Tx Power Req function*/
7130 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7131 vos_mem_free(pWdaParams);
7132 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7133
7134 /* send response to UMAC*/
7135 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7136 pMxTxPwrPerBandParams, 0);
7137
7138 return;
7139}
7140
7141/*
7142 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7143 * Request to WDI to send set Max Tx Power Per band Request
7144 */
7145 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7146 tMaxTxPowerPerBandParams
7147 *MaxTxPowerPerBandParams)
7148{
7149 WDI_Status status = WDI_STATUS_SUCCESS;
7150 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7151 tWDA_ReqParams *pWdaParams = NULL;
7152
7153 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7154 "------> %s ", __func__);
7155
7156 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7157 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7158
7159 if (NULL == wdiSetMxTxPwrPerBandParams)
7160 {
7161 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7162 "%s: VOS MEM Alloc Failure", __func__);
7163 VOS_ASSERT(0);
7164 return VOS_STATUS_E_NOMEM;
7165 }
7166 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7167 if (NULL == pWdaParams)
7168 {
7169 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7170 "%s: VOS MEM Alloc Failure", __func__);
7171 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7172 VOS_ASSERT(0);
7173 return VOS_STATUS_E_NOMEM;
7174 }
7175 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7176 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7177 MaxTxPowerPerBandParams->bandInfo;
7178 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7179 MaxTxPowerPerBandParams->power;
7180 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7181 pWdaParams->pWdaContext = pWDA;
7182 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7183 /* store Params pass it to WDI */
7184 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7185 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7186 WDA_SetMaxTxPowerPerBandCallBack,
7187 pWdaParams);
7188 if (IS_WDI_STATUS_FAILURE(status))
7189 {
7190 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7191 "Failure in SET MAX TX Power REQ Params WDI API,"
7192 " free all the memory");
7193 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7194 vos_mem_free(pWdaParams);
7195 /* send response to UMAC*/
7196 WDA_SendMsg(pWDA,
7197 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7198 MaxTxPowerPerBandParams, 0);
7199 }
7200 return CONVERT_WDI2VOS_STATUS(status);
7201}
7202
7203/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7204 * FUNCTION: WDA_SetTxPowerCallBack
7205 * send the response to PE with power value received from WDI
7206 */
7207void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7208 void* pUserData)
7209{
7210 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7211 tWDA_CbContext *pWDA = NULL;
7212 tSirSetTxPowerReq *pTxPowerParams = NULL;
7213
7214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7215 "<------ %s ", __func__);
7216 if(NULL == pWdaParams)
7217 {
7218 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7219 "%s: pWdaParams received NULL", __func__);
7220 VOS_ASSERT(0) ;
7221 return ;
7222 }
7223 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7224 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7225 if(NULL == pTxPowerParams)
7226 {
7227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7228 "%s: pTxPowerParams received NULL " ,__func__);
7229 VOS_ASSERT(0);
7230 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7231 vos_mem_free(pWdaParams);
7232 return ;
7233 }
7234
7235 /*need to free memory for the pointers used in the
7236 WDA Process.Set Max Tx Power Req function*/
7237 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7238 vos_mem_free(pWdaParams);
7239
7240 /* send response to UMAC*/
7241 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7242 return;
7243}
7244
7245/*
7246 * FUNCTION: WDA_ProcessSetTxPowerReq
7247 * Request to WDI to send set Tx Power Request
7248 */
7249 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7250 tSirSetTxPowerReq *txPowerParams)
7251{
7252 WDI_Status status = WDI_STATUS_SUCCESS;
7253 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7254 tWDA_ReqParams *pWdaParams = NULL;
7255
7256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7257 "------> %s ", __func__);
7258
7259 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7260 sizeof(WDI_SetTxPowerParamsType));
7261 if(NULL == wdiSetTxPowerParams)
7262 {
7263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7264 "%s: VOS MEM Alloc Failure", __func__);
7265 VOS_ASSERT(0);
7266 return VOS_STATUS_E_NOMEM;
7267 }
7268 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7269 if(NULL == pWdaParams)
7270 {
7271 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7272 "%s: VOS MEM Alloc Failure", __func__);
7273 vos_mem_free(wdiSetTxPowerParams);
7274 VOS_ASSERT(0);
7275 return VOS_STATUS_E_NOMEM;
7276 }
7277 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7278 txPowerParams->bssIdx;
7279 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7280 txPowerParams->mwPower;
7281 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7282 pWdaParams->pWdaContext = pWDA;
7283 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7284 /* store Params pass it to WDI */
7285 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7286 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7287 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7288 if(IS_WDI_STATUS_FAILURE(status))
7289 {
7290 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7291 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7293 vos_mem_free(pWdaParams);
7294 /* send response to UMAC*/
7295 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7296 }
7297 return CONVERT_WDI2VOS_STATUS(status);
7298}
7299
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7300/*
7301 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7302 * Free the memory. No need to send any response to PE in this case
7303 */
7304void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7305{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7306 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7309 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7310
7311 if(NULL == pWdaParams)
7312 {
7313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7314 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7315 VOS_ASSERT(0) ;
7316 return ;
7317 }
7318
7319 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7320 vos_mem_free(pWdaParams->wdaMsgParam) ;
7321 vos_mem_free(pWdaParams);
7322
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7323 /*
7324 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7325 * so just free the request param here
7326 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7327 return ;
7328}
7329
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7330/*
7331 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7332 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7333 */
7334VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7335 tP2pPsParams *pP2pPsConfigParams)
7336{
7337 WDI_Status status = WDI_STATUS_SUCCESS ;
7338 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7339 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7340 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7341 tWDA_ReqParams *pWdaParams = NULL;
7342
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7344 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7345 if(NULL == wdiSetP2PGONOAReqParam)
7346 {
7347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7348 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7349 VOS_ASSERT(0);
7350 return VOS_STATUS_E_NOMEM;
7351 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7352
7353 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7354 if(NULL == pWdaParams)
7355 {
7356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7357 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7358 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7359 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7360 VOS_ASSERT(0);
7361 return VOS_STATUS_E_NOMEM;
7362 }
7363
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7364 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7365 pP2pPsConfigParams->opp_ps;
7366 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7367 pP2pPsConfigParams->ctWindow;
7368 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7369 pP2pPsConfigParams->count;
7370 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7371 pP2pPsConfigParams->duration;
7372 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7373 pP2pPsConfigParams->interval;
7374 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7375 pP2pPsConfigParams->single_noa_duration;
7376 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7377 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7378
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7379 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7380 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7381 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7382
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7383 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7384 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7385 pWdaParams->pWdaContext = pWDA;
7386
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7387 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7388 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7389
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7390 if(IS_WDI_STATUS_FAILURE(status))
7391 {
7392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7393 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7394 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7395 vos_mem_free(pWdaParams->wdaMsgParam);
7396 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7397 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7398 return CONVERT_WDI2VOS_STATUS(status);
7399
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7400}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7401
7402#ifdef FEATURE_WLAN_TDLS
7403/*
7404 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7405 * Free the memory. No need to send any response to PE in this case
7406 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7407void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7408 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7409{
7410 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7411 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7412 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7413
7414
7415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7416 "<------ %s " ,__func__);
7417 if(NULL == pWdaParams)
7418 {
7419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7420 "%s: pWdaParams received NULL", __func__);
7421 VOS_ASSERT(0) ;
7422 return ;
7423 }
7424 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7425
7426 if(NULL == pWdaParams)
7427 {
7428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7429 "%s: pWdaParams received NULL", __func__);
7430 VOS_ASSERT(0) ;
7431 return ;
7432 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7433 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7434 if( NULL == pTdlsLinkEstablishParams )
7435 {
7436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7437 "%s: pTdlsLinkEstablishParams "
7438 "received NULL " ,__func__);
7439 VOS_ASSERT(0);
7440 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7441 vos_mem_free(pWdaParams);
7442 return ;
7443 }
7444 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7445 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7446 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7447 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7448 /* send response to UMAC*/
7449 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7450
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7451 return ;
7452}
7453
7454VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7455 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7456{
7457 WDI_Status status = WDI_STATUS_SUCCESS ;
7458 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7459 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7460 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7461 tWDA_ReqParams *pWdaParams = NULL;
7462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7463 "------> %s " ,__func__);
7464 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7465 {
7466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7467 "%s: VOS MEM Alloc Failure", __func__);
7468 VOS_ASSERT(0);
7469 return VOS_STATUS_E_NOMEM;
7470 }
7471 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7472 if(NULL == pWdaParams)
7473 {
7474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7475 "%s: VOS MEM Alloc Failure", __func__);
7476 vos_mem_free(pTdlsLinkEstablishParams);
7477 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7478 VOS_ASSERT(0);
7479 return VOS_STATUS_E_NOMEM;
7480 }
7481 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7482 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7483 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7484 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7485 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7486 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7487 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7488 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7489 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7490 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7491 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7492 pTdlsLinkEstablishParams->isOffChannelSupported;
7493
7494 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7495 pTdlsLinkEstablishParams->validChannels,
7496 pTdlsLinkEstablishParams->validChannelsLen);
7497
7498 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7499 pTdlsLinkEstablishParams->validChannelsLen;
7500
7501 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7502 pTdlsLinkEstablishParams->validOperClasses,
7503 pTdlsLinkEstablishParams->validOperClassesLen);
7504 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7505 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7506
7507 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7508 /* Store msg pointer from PE, as this will be used for response */
7509 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7510 /* store Params pass it to WDI */
7511 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7512 pWdaParams->pWdaContext = pWDA;
7513
7514 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7515 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7516 WDA_SetTDLSLinkEstablishReqParamsCallback,
7517 pWdaParams);
7518 if(IS_WDI_STATUS_FAILURE(status))
7519 {
7520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7521 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7522 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7523 vos_mem_free(pWdaParams->wdaMsgParam);
7524 vos_mem_free(pWdaParams);
7525 }
7526 return CONVERT_WDI2VOS_STATUS(status);
7527}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7528
7529// tdlsoffchan
7530void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
7531 void* pUserData)
7532{
7533 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7534 tWDA_CbContext *pWDA = NULL;
7535 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
7536
7537
7538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7539 "<------ %s " ,__func__);
7540 if(NULL == pWdaParams)
7541 {
7542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7543 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7544 VOS_ASSERT(0) ;
7545 return ;
7546 }
7547 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7548
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7549 if(NULL == pWdaParams)
7550 {
7551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7552 "%s: pWdaParams received NULL", __func__);
7553 VOS_ASSERT(0) ;
7554 return ;
7555 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7556 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7557 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7558 {
7559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7560 "%s: pTdlsChanSwitchParams "
7561 "received NULL " ,__func__);
7562 VOS_ASSERT(0);
7563 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7564 vos_mem_free(pWdaParams);
7565 return ;
7566 }
7567 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
7568 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7569 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7570 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7571 /* send response to UMAC*/
7572 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7573
7574 return ;
7575}
7576VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
7577 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
7578{
7579 WDI_Status status = WDI_STATUS_SUCCESS ;
7580 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
7581 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
7582 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
7583 tWDA_ReqParams *pWdaParams = NULL;
7584
7585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7586 "Enter: %s ",__func__);
7587 if(NULL == wdiSetTDLSChanSwitchReqParam)
7588 {
7589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7590 "%s: VOS MEM Alloc Failure", __func__);
7591 VOS_ASSERT(0);
7592 return VOS_STATUS_E_NOMEM;
7593 }
7594
7595 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7596 if(NULL == pWdaParams)
7597 {
7598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7599 "%s: VOS MEM Alloc Failure", __func__);
7600 vos_mem_free(pTdlsChanSwitchParams);
7601 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
7602 VOS_ASSERT(0);
7603 return VOS_STATUS_E_NOMEM;
7604 }
7605 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
7606 pTdlsChanSwitchParams->staIdx;
7607 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
7608 pTdlsChanSwitchParams->tdlsSwMode;
7609 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
7610 pTdlsChanSwitchParams->operClass;
7611 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
7612 pTdlsChanSwitchParams->tdlsOffCh;
7613 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
7614 pTdlsChanSwitchParams->tdlsOffChBwOffset;
7615
7616
7617 /* Store msg pointer from PE, as this will be used for response */
7618 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
7619 /* store Params pass it to WDI */
7620 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
7621 pWdaParams->pWdaContext = pWDA;
7622 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
7623 (WDI_SetTDLSChanSwitchReqParamsRspCb)
7624 WDA_SetTDLSChanSwitchReqParamsCallback,
7625 pWdaParams);
7626 if(IS_WDI_STATUS_FAILURE(status))
7627 {
7628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7629 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
7630 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7631 vos_mem_free(pWdaParams->wdaMsgParam);
7632 vos_mem_free(pWdaParams);
7633 }
7634 return CONVERT_WDI2VOS_STATUS(status);
7635}
7636#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7637
7638
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7639#ifdef WLAN_FEATURE_VOWIFI_11R
7640/*
7641 * FUNCTION: WDA_AggrAddTSReqCallback
7642 * send ADD AGGREGATED TS RSP back to PE
7643 */
7644void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7645{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7646 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7647 tWDA_CbContext *pWDA;
7648 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7649 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7651 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7652 if(NULL == pWdaParams)
7653 {
7654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7655 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7656 VOS_ASSERT(0) ;
7657 return ;
7658 }
7659
7660 pWDA = pWdaParams->pWdaContext;
7661 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7662
7663 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7664 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7665 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7666 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7667 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7668
7669 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7670 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7671 return ;
7672}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7673/*
7674 * FUNCTION: WDA_ProcessAddTSReq
7675 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7676 */
7677VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7678 tAggrAddTsParams *pAggrAddTsReqParams)
7679{
7680 WDI_Status status = WDI_STATUS_SUCCESS ;
7681 int i;
7682 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7683 tWDA_ReqParams *pWdaParams = NULL;
7684
7685
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7687 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7688 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7689 sizeof(WDI_AggrAddTSReqParamsType)) ;
7690 if(NULL == wdiAggrAddTSReqParam)
7691 {
7692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7693 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7694 VOS_ASSERT(0);
7695 return VOS_STATUS_E_NOMEM;
7696 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7697
7698
7699 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7700 if(NULL == pWdaParams)
7701 {
7702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7703 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7704 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7705 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7706 VOS_ASSERT(0);
7707 return VOS_STATUS_E_NOMEM;
7708 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7709 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7710 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7711 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7712 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7713 {
7714 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7715 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7716 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7717 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7718 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7719 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7720 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7721 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7722 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7723 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7724 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7725 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7726 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7727 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7728 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7729 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7730 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7731 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7732 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7733 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7734 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7735 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7736 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7737 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7738 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7739 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7740 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7741 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7742 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7743 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7744 pAggrAddTsReqParams->tspec[i].inactInterval;
7745 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7746 pAggrAddTsReqParams->tspec[i].suspendInterval;
7747 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7748 pAggrAddTsReqParams->tspec[i].svcStartTime;
7749 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7750 pAggrAddTsReqParams->tspec[i].minDataRate;
7751 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7752 pAggrAddTsReqParams->tspec[i].meanDataRate;
7753 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7754 pAggrAddTsReqParams->tspec[i].peakDataRate;
7755 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7756 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7757 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7758 pAggrAddTsReqParams->tspec[i].delayBound;
7759 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7760 pAggrAddTsReqParams->tspec[i].minPhyRate;
7761 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7762 pAggrAddTsReqParams->tspec[i].surplusBw;
7763 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7764 pAggrAddTsReqParams->tspec[i].mediumTime;
7765 }
7766
7767 /* TODO: tAggrAddTsParams doesn't have the following fields */
7768#if 0
7769 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7770 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7771 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7772 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7773#endif
7774 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7775
7776 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7777 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7778 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7779 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7780
7781 pWdaParams->pWdaContext = pWDA;
7782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7783 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7784 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7785
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7786 if(IS_WDI_STATUS_FAILURE(status))
7787 {
7788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7789 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7790 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7791 vos_mem_free(pWdaParams);
7792
7793 /* send the failure response back to PE*/
7794 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7795 {
7796 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7797 }
7798
7799 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7800 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7801 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7802 return CONVERT_WDI2VOS_STATUS(status) ;
7803}
7804#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7805/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7806 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7807 * send Enter IMPS RSP back to PE
7808 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7809void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7810{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7811 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7812 tWDA_CbContext *pWDA;
7813
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7815 "<------ %s status=%d" ,__func__,status);
7816 if(NULL == pWdaParams)
7817 {
7818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7819 "%s: pWdaParams received NULL", __func__);
7820 VOS_ASSERT(0);
7821 return;
7822 }
7823
7824 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7825
7826 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7827 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7828 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7829 return ;
7830}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7831
7832
7833/*
7834 * FUNCTION: WDA_EnterImpsReqCallback
7835 * Free memory and send Enter IMPS RSP back to PE.
7836 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7837 */
7838void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7839{
7840 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7841 tWDA_CbContext *pWDA;
7842
7843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7844 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7845
7846 if(NULL == pWdaParams)
7847 {
7848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7849 "%s: pWdaParams received NULL", __func__);
7850 VOS_ASSERT(0);
7851 return;
7852 }
7853
7854 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7855
7856 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7857 {
7858 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7859 vos_mem_free(pWdaParams);
7860 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7861 CONVERT_WDI2SIR_STATUS(wdiStatus));
7862 }
7863
7864 return;
7865}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7866/*
7867 * FUNCTION: WDA_ProcessEnterImpsReq
7868 * Request to WDI to Enter IMPS power state.
7869 */
7870VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7871{
7872 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7873 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7874 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7876 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7877
7878
7879 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7880 if (NULL == wdiEnterImpsReqParams)
7881 {
7882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7883 "%s: VOS MEM Alloc Failure", __func__);
7884 VOS_ASSERT(0);
7885 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7886 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7887 return VOS_STATUS_E_NOMEM;
7888 }
7889
7890 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7891 if (NULL == pWdaParams)
7892 {
7893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7894 "%s: VOS MEM Alloc Failure", __func__);
7895 VOS_ASSERT(0);
7896 vos_mem_free(wdiEnterImpsReqParams);
7897 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7898 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7899 return VOS_STATUS_E_NOMEM;
7900 }
7901
7902 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7903 wdiEnterImpsReqParams->pUserData = pWdaParams;
7904
7905 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7906 pWdaParams->wdaMsgParam = NULL;
7907 pWdaParams->pWdaContext = pWDA;
7908
7909 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7910 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7911 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7912 if(IS_WDI_STATUS_FAILURE(status))
7913 {
7914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7915 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7916 vos_mem_free(wdiEnterImpsReqParams);
7917 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7918 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7920 return CONVERT_WDI2VOS_STATUS(status) ;
7921}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7922/*
7923 * FUNCTION: WDA_ExitImpsReqCallback
7924 * send Exit IMPS RSP back to PE
7925 */
7926void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7927{
7928 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7929 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7930 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7931 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7932 return ;
7933}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7934/*
7935 * FUNCTION: WDA_ProcessExitImpsReq
7936 * Request to WDI to Exit IMPS power state.
7937 */
7938VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7939{
7940 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7942 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7943 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7944 if(IS_WDI_STATUS_FAILURE(status))
7945 {
7946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7947 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7948 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7949 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7950 return CONVERT_WDI2VOS_STATUS(status) ;
7951}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7952/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7953 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7954 * send Enter BMPS RSP back to PE
7955 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7956void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7957{
7958 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7959 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7960 tEnterBmpsParams *pEnterBmpsRspParams;
7961
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7963 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7964 if(NULL == pWdaParams)
7965 {
7966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7967 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7968 VOS_ASSERT(0) ;
7969 return ;
7970 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7971
7972 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7973 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7974
7975 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7976 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7977
7978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7979 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7980 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
7981
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7982 return ;
7983}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7984/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7985 * FUNCTION: WDA_EnterBmpsReqCallback
7986 * Free memory and send Enter BMPS RSP back to PE.
7987 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
7988 */
7989void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7990{
7991 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7992 tWDA_CbContext *pWDA;
7993 tEnterBmpsParams *pEnterBmpsRspParams;
7994
7995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7996 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7997
7998 if(NULL == pWdaParams)
7999 {
8000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8001 "%s: pWdaParams received NULL", __func__);
8002 VOS_ASSERT(0);
8003 return;
8004 }
8005
8006 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8007 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8008 pEnterBmpsRspParams->status = wdiStatus;
8009
8010 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8011 {
8012 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8013 vos_mem_free(pWdaParams);
8014 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
8015 }
8016
8017 return;
8018}
8019/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8020 * FUNCTION: WDA_ProcessEnterBmpsReq
8021 * Request to WDI to Enter BMPS power state.
8022 */
8023VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
8024 tEnterBmpsParams *pEnterBmpsReqParams)
8025{
8026 WDI_Status status = WDI_STATUS_SUCCESS;
8027 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
8028 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8030 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8031 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
8032 {
8033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8034 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8035 VOS_ASSERT(0);
8036 return VOS_STATUS_E_FAILURE;
8037 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8038 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
8039 if (NULL == wdiEnterBmpsReqParams)
8040 {
8041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8042 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8043 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8044 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8045 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8046 return VOS_STATUS_E_NOMEM;
8047 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8048 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8049 if (NULL == pWdaParams)
8050 {
8051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8052 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8053 VOS_ASSERT(0);
8054 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8055 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8056 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8057 return VOS_STATUS_E_NOMEM;
8058 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8059 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
8060 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
8061 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
8062 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]8063 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8064 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
8065 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
8066 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8067 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
8068 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8069
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8070 /* Store param pointer as passed in by caller */
8071 /* store Params pass it to WDI */
8072 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8073 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8074 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8075 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8076 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8077 if (IS_WDI_STATUS_FAILURE(status))
8078 {
8079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8080 "Failure in Enter BMPS REQ WDI API, free all the memory" );
8081 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8082 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8083 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8084 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8085 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8086 return CONVERT_WDI2VOS_STATUS(status);
8087}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8088
8089
8090static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
8091 WDI_Status wdiStatus,
8092 tExitBmpsParams *pExitBmpsReqParams)
8093{
8094 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
8095
8096 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
8097}
8098
8099
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8100/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8101 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8102 * send Exit BMPS RSP back to PE
8103 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8104void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8105{
8106 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8107 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8108 tExitBmpsParams *pExitBmpsRspParams;
8109
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8111 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8112 if(NULL == pWdaParams)
8113 {
8114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8115 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8116 VOS_ASSERT(0) ;
8117 return ;
8118 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8119
8120 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8121 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8122
8123 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8124 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8125
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8126 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8127 vos_mem_free(pWdaParams) ;
8128
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8129 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8130 return ;
8131}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8132/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8133 * FUNCTION: WDA_ExitBmpsReqCallback
8134 * Free memory and send Exit BMPS RSP back to PE.
8135 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
8136 */
8137void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8138{
8139 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8140 tWDA_CbContext *pWDA;
8141 tExitBmpsParams *pExitBmpsRspParams;
8142
8143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8144 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8145
8146 if(NULL == pWdaParams)
8147 {
8148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8149 "%s: pWdaParams received NULL", __func__);
8150 VOS_ASSERT(0);
8151 return;
8152 }
8153
8154 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8155 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8156 pExitBmpsRspParams->status = wdiStatus;
8157
8158 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8159 {
8160 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8161 vos_mem_free(pWdaParams);
8162 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
8163 }
8164
8165 return;
8166}
8167/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8168 * FUNCTION: WDA_ProcessExitBmpsReq
8169 * Request to WDI to Exit BMPS power state.
8170 */
8171VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
8172 tExitBmpsParams *pExitBmpsReqParams)
8173{
8174 WDI_Status status = WDI_STATUS_SUCCESS ;
8175 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
8176 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
8177 sizeof(WDI_ExitBmpsReqParamsType)) ;
8178 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8180 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8181 if(NULL == wdiExitBmpsReqParams)
8182 {
8183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8184 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8185 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8186 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8187 return VOS_STATUS_E_NOMEM;
8188 }
8189 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8190 if(NULL == pWdaParams)
8191 {
8192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8193 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8194 VOS_ASSERT(0);
8195 vos_mem_free(wdiExitBmpsReqParams);
8196 return VOS_STATUS_E_NOMEM;
8197 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8198 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8199
8200 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
8201
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8202 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
8203 wdiExitBmpsReqParams->pUserData = pWdaParams;
8204
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8205 /* Store param pointer as passed in by caller */
8206 /* store Params pass it to WDI */
8207 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
8208 pWdaParams->pWdaContext = pWDA;
8209 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8210 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8211 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8212 if(IS_WDI_STATUS_FAILURE(status))
8213 {
8214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8215 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8216 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8217 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8218 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8219 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8220 return CONVERT_WDI2VOS_STATUS(status) ;
8221}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8222/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8223 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8224 * send Enter UAPSD RSP back to PE
8225 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8226void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8227{
8228 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8229 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8230 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8231 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8232 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8233 if(NULL == pWdaParams)
8234 {
8235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8236 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8237 VOS_ASSERT(0) ;
8238 return ;
8239 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8240
8241 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8242 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8243
8244 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8245 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8246
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8247 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8248 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8249 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8250 return ;
8251}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8252/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8253 * FUNCTION: WDA_EnterUapsdReqCallback
8254 * Free memory and send Enter UAPSD RSP back to PE.
8255 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8256 */
8257void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8258{
8259 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8260 tWDA_CbContext *pWDA;
8261 tUapsdParams *pEnterUapsdRsqParams;
8262
8263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8264 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8265
8266 if(NULL == pWdaParams)
8267 {
8268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8269 "%s: pWdaParams received NULL", __func__);
8270 VOS_ASSERT(0);
8271 return;
8272 }
8273
8274 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8275 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8276 pEnterUapsdRsqParams->status = wdiStatus;
8277
8278 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8279 {
8280 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8281 vos_mem_free(pWdaParams);
8282 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8283 }
8284
8285 return;
8286}
8287/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8288 * FUNCTION: WDA_ProcessEnterUapsdReq
8289 * Request to WDI to Enter UAPSD power state.
8290 */
8291VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8292 tUapsdParams *pEnterUapsdReqParams)
8293{
8294 WDI_Status status = WDI_STATUS_SUCCESS ;
8295 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8296 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8297 sizeof(WDI_EnterUapsdReqParamsType)) ;
8298 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8300 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8301 if(NULL == wdiEnterUapsdReqParams)
8302 {
8303 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8304 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8305 VOS_ASSERT(0);
8306 return VOS_STATUS_E_NOMEM;
8307 }
8308 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8309 if(NULL == pWdaParams)
8310 {
8311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8312 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8313 VOS_ASSERT(0);
8314 vos_mem_free(wdiEnterUapsdReqParams);
8315 return VOS_STATUS_E_NOMEM;
8316 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8317 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8318 pEnterUapsdReqParams->beDeliveryEnabled;
8319 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8320 pEnterUapsdReqParams->beTriggerEnabled;
8321 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8322 pEnterUapsdReqParams->bkDeliveryEnabled;
8323 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8324 pEnterUapsdReqParams->bkTriggerEnabled;
8325 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8326 pEnterUapsdReqParams->viDeliveryEnabled;
8327 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8328 pEnterUapsdReqParams->viTriggerEnabled;
8329 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8330 pEnterUapsdReqParams->voDeliveryEnabled;
8331 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8332 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8333 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8334
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8335 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8336 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8338 /* Store param pointer as passed in by caller */
8339 /* store Params pass it to WDI */
8340 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8341 pWdaParams->pWdaContext = pWDA;
8342 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8343 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8344 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8345 if(IS_WDI_STATUS_FAILURE(status))
8346 {
8347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8348 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8349 vos_mem_free(pWdaParams->wdaMsgParam) ;
8350 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8351 vos_mem_free(pWdaParams) ;
8352 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8353 return CONVERT_WDI2VOS_STATUS(status) ;
8354}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8355/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8356 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8357 * send Exit UAPSD RSP back to PE
8358 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8359void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8360{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8361
8362 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8363 tWDA_CbContext *pWDA;
8364 tExitUapsdParams *pExitUapsdRspParams;
8365
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8367 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8368 if(NULL == pWdaParams)
8369 {
8370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8371 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8372 VOS_ASSERT(0);
8373 return;
8374 }
8375
8376 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8377 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8378
8379 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8380 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8381
8382 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8383 vos_mem_free(pWdaParams) ;
8384
8385 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8386 return ;
8387}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8388/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8389 * FUNCTION: WDA_ExitUapsdReqCallback
8390 * Free memory and send Exit UAPSD RSP back to PE.
8391 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8392 */
8393void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8394{
8395 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8396 tWDA_CbContext *pWDA;
8397 tExitUapsdParams *pExitUapsdRspParams;
8398
8399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8400 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8401
8402 if(NULL == pWdaParams)
8403 {
8404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8405 "%s: pWdaParams received NULL", __func__);
8406 VOS_ASSERT(0);
8407 return;
8408 }
8409
8410 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8411 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8412 pExitUapsdRspParams->status = wdiStatus;
8413
8414 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8415 {
8416 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8417 vos_mem_free(pWdaParams);
8418 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8419 }
8420
8421 return;
8422}
8423/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8424 * FUNCTION: WDA_ProcessExitUapsdReq
8425 * Request to WDI to Exit UAPSD power state.
8426 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8427VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8428 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8429{
8430 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8431 tWDA_ReqParams *pWdaParams ;
8432 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8433 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8434 sizeof(WDI_ExitUapsdReqParamsType)) ;
8435
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8437 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8438
8439 if(NULL == wdiExitUapsdReqParams)
8440 {
8441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8442 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8443 VOS_ASSERT(0);
8444 return VOS_STATUS_E_NOMEM;
8445 }
8446 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8447 if(NULL == pWdaParams)
8448 {
8449 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8450 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8451 VOS_ASSERT(0);
8452 vos_mem_free(wdiExitUapsdReqParams);
8453 return VOS_STATUS_E_NOMEM;
8454 }
8455
8456 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8457 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8458 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8459
8460 /* Store param pointer as passed in by caller */
8461 /* store Params pass it to WDI */
8462 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8463 pWdaParams->pWdaContext = pWDA;
8464 pWdaParams->wdaMsgParam = pExitUapsdParams;
8465
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8466 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8467 if(IS_WDI_STATUS_FAILURE(status))
8468 {
8469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8470 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8471 vos_mem_free(pWdaParams->wdaMsgParam) ;
8472 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8473 vos_mem_free(pWdaParams) ;
8474
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8475 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8476 return CONVERT_WDI2VOS_STATUS(status) ;
8477}
8478
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8479/*
8480 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8481 *
8482 */
8483void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8484{
8485 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8487 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8488 if(NULL == pWdaParams)
8489 {
8490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8491 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8492 VOS_ASSERT(0) ;
8493 return ;
8494 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8495 if( pWdaParams != NULL )
8496 {
8497 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8498 {
8499 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8500 }
8501 if( pWdaParams->wdaMsgParam != NULL )
8502 {
8503 vos_mem_free(pWdaParams->wdaMsgParam) ;
8504 }
8505 vos_mem_free(pWdaParams) ;
8506 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8507 return ;
8508}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8509/*
8510 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8511 * Request to WDI to set the power save params at start.
8512 */
8513VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8514 tSirPowerSaveCfg *pPowerSaveCfg)
8515{
8516 WDI_Status status = WDI_STATUS_SUCCESS ;
8517 tHalCfg *tlvStruct = NULL ;
8518 tANI_U8 *tlvStructStart = NULL ;
8519 v_PVOID_t *configParam;
8520 tANI_U32 configParamSize;
8521 tANI_U32 *configDataValue;
8522 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8523 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8525 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8526 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8527 {
8528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8529 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8530 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8531 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8532 return VOS_STATUS_E_FAILURE;
8533 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8534 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8535 if (NULL == wdiPowerSaveCfg)
8536 {
8537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8538 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8539 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8540 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8541 return VOS_STATUS_E_NOMEM;
8542 }
8543 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8548 VOS_ASSERT(0);
8549 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8550 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8551 return VOS_STATUS_E_NOMEM;
8552 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8553 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8554 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8555 if(NULL == configParam)
8556 {
8557 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8558 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8559 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8560 vos_mem_free(pWdaParams);
8561 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8562 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8563 return VOS_STATUS_E_NOMEM;
8564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8565 vos_mem_set(configParam, configParamSize, 0);
8566 wdiPowerSaveCfg->pConfigBuffer = configParam;
8567 tlvStruct = (tHalCfg *)configParam;
8568 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8569 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8570 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8571 tlvStruct->length = sizeof(tANI_U32);
8572 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8573 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8574 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8575 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8576 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8577 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8578 tlvStruct->length = sizeof(tANI_U32);
8579 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8580 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8581 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8582 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8583 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8584 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8585 tlvStruct->length = sizeof(tANI_U32);
8586 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8587 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8588 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8589 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8590 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8591 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8592 tlvStruct->length = sizeof(tANI_U32);
8593 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8594 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8595 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8596 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8597 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8598 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8599 tlvStruct->length = sizeof(tANI_U32);
8600 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8601 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8602 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8603 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8604 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8605 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8606 tlvStruct->length = sizeof(tANI_U32);
8607 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8608 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8611 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8612 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8613 tlvStruct->length = sizeof(tANI_U32);
8614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8615 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8616 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8617 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8618 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8619 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8620 tlvStruct->length = sizeof(tANI_U32);
8621 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8622 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8623 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8624 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8625 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8626 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8627 tlvStruct->length = sizeof(tANI_U32);
8628 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8629 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
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_NUM_BEACON_PER_RSSI_AVERAGE */
8633 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8634 tlvStruct->length = sizeof(tANI_U32);
8635 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8636 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
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_RSSI_FILTER_PERIOD */
8640 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8641 tlvStruct->length = sizeof(tANI_U32);
8642 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8643 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
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 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8647 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8648 /* store Params pass it to WDI */
8649 pWdaParams->wdaMsgParam = configParam;
8650 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8651 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8652 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8653 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8654 if(IS_WDI_STATUS_FAILURE(status))
8655 {
8656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8657 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8658 vos_mem_free(pWdaParams->wdaMsgParam);
8659 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8660 vos_mem_free(pWdaParams);
8661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8662 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8663 return CONVERT_WDI2VOS_STATUS(status);
8664}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8665/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8666 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8667 *
8668 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8669void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8670{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8671 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8672
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8674 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8675
8676 if(NULL == pWdaParams)
8677 {
8678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8679 "%s: pWdaParams received NULL", __func__);
8680 VOS_ASSERT(0);
8681 return ;
8682 }
8683
8684 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8685 vos_mem_free(pWdaParams);
8686
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8687 return ;
8688}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8689/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8690 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8691 * Free memory.
8692 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8693 */
8694void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8695{
8696 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8697
8698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8699 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8700
8701 if(NULL == pWdaParams)
8702 {
8703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8704 "%s: pWdaParams received NULL", __func__);
8705 VOS_ASSERT(0);
8706 return;
8707 }
8708
8709 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8710 {
8711 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8712 vos_mem_free(pWdaParams);
8713 }
8714
8715 return;
8716}
8717/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8718 * FUNCTION: WDA_SetUapsdAcParamsReq
8719 * Request to WDI to set the UAPSD params for an ac (sta mode).
8720 */
8721VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8722 tUapsdInfo *pUapsdInfo)
8723{
8724 WDI_Status status = WDI_STATUS_SUCCESS;
8725 tWDA_CbContext *pWDA = NULL ;
8726 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8727 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8728 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8729 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8731 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8732 if(NULL == wdiUapsdParams)
8733 {
8734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8735 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8736 VOS_ASSERT(0);
8737 return VOS_STATUS_E_NOMEM;
8738 }
8739 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8740 if(NULL == pWdaParams)
8741 {
8742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8743 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8744 VOS_ASSERT(0);
8745 vos_mem_free(wdiUapsdParams);
8746 return VOS_STATUS_E_NOMEM;
8747 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8748 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8749 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8750 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8751 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8752 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8753 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8754 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8755 wdiUapsdParams->pUserData = pWdaParams;
8756
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8757 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8758 pWdaParams->pWdaContext = pWDA;
8759 /* Store param pointer as passed in by caller */
8760 pWdaParams->wdaMsgParam = pUapsdInfo;
8761 /* store Params pass it to WDI */
8762 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8763 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8764 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8765 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8766 if(IS_WDI_STATUS_FAILURE(status))
8767 {
8768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8769 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8770 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8771 vos_mem_free(pWdaParams);
8772 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8773 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8774 return VOS_STATUS_SUCCESS;
8775 else
8776 return VOS_STATUS_E_FAILURE;
8777
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8778}
8779/*
8780 * FUNCTION: WDA_ClearUapsdAcParamsReq
8781 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8782 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8783 * and again enter the UPASD with the modified params. Hence the disable
8784 * function was kept empty.
8785 *
8786 */
8787VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8788{
8789 /* do nothing */
8790 return VOS_STATUS_SUCCESS;
8791}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8792/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8793 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8794 *
8795 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8796void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8797{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8798 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8799
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8801 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8802
8803 if(NULL == pWdaParams)
8804 {
8805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8806 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8807 VOS_ASSERT(0) ;
8808 return ;
8809 }
8810
8811 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8812 vos_mem_free(pWdaParams->wdaMsgParam);
8813 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8814
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8815 //print a msg, nothing else to do
8816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8817 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8818 return ;
8819}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8820/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8821 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8822 * Free memory.
8823 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8824 */
8825void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8826{
8827 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8828
8829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8830 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8831
8832 if(NULL == pWdaParams)
8833 {
8834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8835 "%s: pWdaParams received NULL", __func__);
8836 VOS_ASSERT(0);
8837 return;
8838 }
8839
8840 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8841 {
8842 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8843 vos_mem_free(pWdaParams->wdaMsgParam);
8844 vos_mem_free(pWdaParams);
8845 }
8846
8847 return;
8848}
8849/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8850 * FUNCTION: WDA_UpdateUapsdParamsReq
8851 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8852 */
8853VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8854 tUpdateUapsdParams* pUpdateUapsdInfo)
8855{
8856 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8857 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8858 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8859 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8860 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8861 tWDA_ReqParams *pWdaParams = NULL;
8862
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8864 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8865 if(NULL == wdiUpdateUapsdParams)
8866 {
8867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8868 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8869 VOS_ASSERT(0);
8870 return VOS_STATUS_E_NOMEM;
8871 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8872 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8873 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8874 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8875 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8876 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8877
8878 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8879 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8880 {
8881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8883 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8884 vos_mem_free(pUpdateUapsdInfo);
8885 vos_mem_free(wdiUpdateUapsdParams);
8886 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8888 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8889 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8890 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8891 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8892 pWdaParams->pWdaContext = pWDA;
8893
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8894 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8895 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8896 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8897
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8898 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8899 {
8900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8901 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8902 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8903 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8904 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8905 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8906 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8907 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8908}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8909/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8910 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8911 *
8912 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8913void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8914{
8915 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8917 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8918 if(WDI_STATUS_SUCCESS != wdiStatus)
8919 {
8920 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8921 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8922 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8923 if(NULL == pWdaParams)
8924 {
8925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8926 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8927 VOS_ASSERT(0) ;
8928 return ;
8929 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8930 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8931 vos_mem_free(pWdaParams->wdaMsgParam);
8932 vos_mem_free(pWdaParams);
8933 return ;
8934}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8935/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8936 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8937 * Free memory.
8938 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8939 */
8940void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8941{
8942 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8943
8944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8945 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8946
8947 if(NULL == pWdaParams)
8948 {
8949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8950 "%s: pWdaParams received NULL", __func__);
8951 VOS_ASSERT(0);
8952 return;
8953 }
8954
8955 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8956 {
8957 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8958 vos_mem_free(pWdaParams->wdaMsgParam);
8959 vos_mem_free(pWdaParams);
8960 }
8961
8962 return;
8963}
8964/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8965 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
8966 *
8967 */
8968VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
8969 tSirWlanSetRxpFilters *pWlanSuspendParam)
8970{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8971 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8972 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8973 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8974 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8975 /* Sanity Check
8976 * This is very unlikely and add assert to collect more info next time */
8977 if(NULL == pWlanSuspendParam)
8978 {
8979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8980 "%s: pWlanSuspendParam received NULL", __func__);
8981 VOS_ASSERT(0) ;
8982 return VOS_STATUS_E_FAULT;
8983 }
8984 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
8985 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8987 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8988 if(NULL == wdiRxpFilterParams)
8989 {
8990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8991 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8992 VOS_ASSERT(0);
8993 vos_mem_free(pWlanSuspendParam);
8994 return VOS_STATUS_E_NOMEM;
8995 }
8996 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8997 if(NULL == pWdaParams)
8998 {
8999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9000 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9001 VOS_ASSERT(0);
9002 vos_mem_free(wdiRxpFilterParams);
9003 vos_mem_free(pWlanSuspendParam);
9004 return VOS_STATUS_E_NOMEM;
9005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9006 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
9007 pWlanSuspendParam->setMcstBcstFilter;
9008 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
9009 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9010
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9011 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
9012 wdiRxpFilterParams->pUserData = pWdaParams;
9013
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9014 pWdaParams->pWdaContext = pWDA;
9015 pWdaParams->wdaMsgParam = pWlanSuspendParam;
9016 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9017 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9018 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9019 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9020 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9021 {
9022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9023 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9024 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9025 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9026 vos_mem_free(pWdaParams->wdaMsgParam);
9027 vos_mem_free(pWdaParams);
9028 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9029 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9030}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9031/*
9032 * FUNCTION: WDA_WdiIndicationCallback
9033 *
9034 */
9035void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
9036 void* pUserData)
9037{
9038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9039 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9040}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9041/*
9042 * FUNCTION: WDA_ProcessWlanSuspendInd
9043 *
9044 */
9045VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
9046 tSirWlanSuspendParam *pWlanSuspendParam)
9047{
9048 WDI_Status wdiStatus;
9049 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9051 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9052 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
9053 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9054 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
9055 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9056 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]9057 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
9058 if(WDI_STATUS_PENDING == wdiStatus)
9059 {
9060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9061 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9062 }
9063 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9064 {
9065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9066 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9067 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9068 vos_mem_free(pWlanSuspendParam);
9069 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9070}
9071
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]9072#ifdef WLAN_FEATURE_11W
9073/*
9074 * FUNCTION: WDA_ProcessExcludeUnecryptInd
9075 *
9076 */
9077VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
9078 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
9079{
9080 WDI_Status wdiStatus;
9081 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
9082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9083 "------> %s ", __func__);
9084
9085 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
9086 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
9087 sizeof(tSirMacAddr));
9088
9089 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
9090 wdiExclUnencryptParams.pUserData = pWDA;
9091
9092 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
9093 if(WDI_STATUS_PENDING == wdiStatus)
9094 {
9095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9096 "Pending received for %s:%d ", __func__, __LINE__ );
9097 }
9098 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9099 {
9100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9101 "Failure in %s:%d ", __func__, __LINE__ );
9102 }
9103 vos_mem_free(pExclUnencryptParam);
9104 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9105}
9106#endif
9107
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9108/*
9109 * FUNCTION: WDA_ProcessWlanResumeCallback
9110 *
9111 */
9112void WDA_ProcessWlanResumeCallback(
9113 WDI_SuspendResumeRspParamsType *resumeRspParams,
9114 void* pUserData)
9115{
9116 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9118 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9119 if(NULL == pWdaParams)
9120 {
9121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9122 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9123 VOS_ASSERT(0) ;
9124 return ;
9125 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9126 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
9127 {
9128 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9129 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9130 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9131 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9132 vos_mem_free(pWdaParams->wdaMsgParam);
9133 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9134 return ;
9135}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9136/*
9137 * FUNCTION: WDA_ProcessWlanResumeReq
9138 *
9139 */
9140VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
9141 tSirWlanResumeParam *pWlanResumeParam)
9142{
9143 WDI_Status wdiStatus;
9144 WDI_ResumeParamsType *wdiResumeParams =
9145 (WDI_ResumeParamsType *)vos_mem_malloc(
9146 sizeof(WDI_ResumeParamsType) ) ;
9147 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9149 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9150 if(NULL == wdiResumeParams)
9151 {
9152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9153 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9154 VOS_ASSERT(0);
9155 return VOS_STATUS_E_NOMEM;
9156 }
9157 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9158 if(NULL == pWdaParams)
9159 {
9160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9161 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9162 VOS_ASSERT(0);
9163 vos_mem_free(wdiResumeParams);
9164 return VOS_STATUS_E_NOMEM;
9165 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9166 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
9167 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9168 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]9169 wdiResumeParams->wdiReqStatusCB = NULL;
9170 pWdaParams->wdaMsgParam = pWlanResumeParam;
9171 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
9172 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9173 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
9174 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
9175 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9176 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9177 {
9178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9179 "Failure in Host Resume REQ WDI API, free all the memory " );
9180 VOS_ASSERT(0);
9181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9182 vos_mem_free(pWdaParams->wdaMsgParam);
9183 vos_mem_free(pWdaParams);
9184 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9185 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9186}
9187
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9188/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9189 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9190 *
9191 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9192void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9193{
9194 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9196 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9197 if(NULL == pWdaParams)
9198 {
9199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9200 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9201 VOS_ASSERT(0) ;
9202 return ;
9203 }
9204
9205 vos_mem_free(pWdaParams->wdaMsgParam) ;
9206 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9207 vos_mem_free(pWdaParams) ;
9208 /*
9209 * No respone required for SetBeaconFilter req so just free the request
9210 * param here
9211 */
9212
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9213 return ;
9214}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9215/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9216 * FUNCTION: WDA_SetBeaconFilterReqCallback
9217 * Free memory.
9218 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
9219 */
9220void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9221{
9222 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9223
9224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9225 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9226
9227 if(NULL == pWdaParams)
9228 {
9229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9230 "%s: pWdaParams received NULL", __func__);
9231 VOS_ASSERT(0);
9232 return;
9233 }
9234
9235 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9236 {
9237 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9238 vos_mem_free(pWdaParams->wdaMsgParam);
9239 vos_mem_free(pWdaParams);
9240 }
9241
9242 return;
9243}
9244/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9245 * FUNCTION: WDA_SetBeaconFilterReq
9246 * Request to WDI to send the beacon filtering related information.
9247 */
9248VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9249 tBeaconFilterMsg* pBeaconFilterInfo)
9250{
9251 WDI_Status status = WDI_STATUS_SUCCESS;
9252 tANI_U8 *dstPtr, *srcPtr;
9253 tANI_U8 filterLength;
9254 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9255 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9256 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9257 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9259 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9260 if(NULL == wdiBeaconFilterInfo)
9261 {
9262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9263 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9264 VOS_ASSERT(0);
9265 return VOS_STATUS_E_NOMEM;
9266 }
9267 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9268 if(NULL == pWdaParams)
9269 {
9270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9271 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9272 VOS_ASSERT(0);
9273 vos_mem_free(wdiBeaconFilterInfo);
9274 return VOS_STATUS_E_NOMEM;
9275 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9276 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9277 pBeaconFilterInfo->beaconInterval;
9278 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9279 pBeaconFilterInfo->capabilityInfo;
9280 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9281 pBeaconFilterInfo->capabilityMask;
9282 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9283
9284 //Fill the BssIdx
9285 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9286
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9287 //Fill structure with info contained in the beaconFilterTable
9288 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9289 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9290 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9291 if(WDI_BEACON_FILTER_LEN < filterLength)
9292 {
9293 filterLength = WDI_BEACON_FILTER_LEN;
9294 }
9295 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9296 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9297 wdiBeaconFilterInfo->pUserData = pWdaParams;
9298
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9299 /* Store param pointer as passed in by caller */
9300 /* store Params pass it to WDI */
9301 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9302 pWdaParams->pWdaContext = pWDA;
9303 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9304
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9305 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9306 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9307 if(IS_WDI_STATUS_FAILURE(status))
9308 {
9309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9310 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9311 vos_mem_free(pWdaParams->wdaMsgParam) ;
9312 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9313 vos_mem_free(pWdaParams) ;
9314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9315 return CONVERT_WDI2VOS_STATUS(status) ;
9316}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9317/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9318 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9319 *
9320 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9321void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9322{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9323 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9324
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9326 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9327
9328 if(NULL == pWdaParams)
9329 {
9330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9331 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9332 VOS_ASSERT(0) ;
9333 return ;
9334 }
9335
9336 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9337 vos_mem_free(pWdaParams->wdaMsgParam);
9338 vos_mem_free(pWdaParams);
9339
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9340 //print a msg, nothing else to do
9341 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9342 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9343 return ;
9344}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9345/*
9346 * FUNCTION: WDA_RemBeaconFilterReqCallback
9347 * Free memory.
9348 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9349 */
9350void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9351{
9352 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9353
9354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9355 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9356
9357 if(NULL == pWdaParams)
9358 {
9359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9360 "%s: pWdaParams received NULL", __func__);
9361 VOS_ASSERT(0);
9362 return;
9363 }
9364
9365 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9366 {
9367 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9368 vos_mem_free(pWdaParams->wdaMsgParam);
9369 vos_mem_free(pWdaParams);
9370 }
9371
9372 return;
9373}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9374 // TODO: PE does not have this feature for now implemented,
9375 // but the support for removing beacon filter exists between
9376 // HAL and FW. This function can be called whenever PE defines
9377 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9378/*
9379 * FUNCTION: WDA_RemBeaconFilterReq
9380 * Request to WDI to send the removal of beacon filtering related information.
9381 */
9382VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9383 tRemBeaconFilterMsg* pBeaconFilterInfo)
9384{
9385 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9386 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9387 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9388 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9389 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9390 tWDA_ReqParams *pWdaParams ;
9391
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9393 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9394 if(NULL == wdiBeaconFilterInfo)
9395 {
9396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9397 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9398 VOS_ASSERT(0);
9399 return VOS_STATUS_E_NOMEM;
9400 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9401 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9402 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9403 {
9404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9405 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9406 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9407 vos_mem_free(wdiBeaconFilterInfo);
9408 vos_mem_free(pBeaconFilterInfo);
9409 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9410 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9411
9412 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9413 pBeaconFilterInfo->ucIeCount;
9414 //Fill structure with info contained in the ucRemIeId
9415 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9416 pBeaconFilterInfo->ucRemIeId,
9417 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9418 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9419 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9420
9421 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9422 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9423 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9424 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9425
9426 pWdaParams->pWdaContext = pWDA;
9427
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9428 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9429 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9430 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9431 {
9432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9433 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9434 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9435 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9436 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9437 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9438 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9439 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9440}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9441/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9442 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9443 *
9444 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9445void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9446{
9447 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
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 == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9454 VOS_ASSERT(0) ;
9455 return ;
9456 }
9457
9458 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9459 vos_mem_free(pWdaParams) ;
9460
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9461 return ;
9462}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9463/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9464 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9465 * Free memory.
9466 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9467 */
9468void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9469{
9470 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9471
9472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9473 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9474
9475 if(NULL == pWdaParams)
9476 {
9477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9478 "%s: pWdaParams received NULL", __func__);
9479 VOS_ASSERT(0);
9480 return;
9481 }
9482
9483 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9484 {
9485 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9486 vos_mem_free(pWdaParams);
9487 }
9488
9489 return;
9490}
9491/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9492 * FUNCTION: WDA_SetRSSIThresholdsReq
9493 * Request to WDI to set the RSSI thresholds (sta mode).
9494 */
9495VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9496{
9497 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9498 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9499 tWDA_CbContext *pWDA = NULL ;
9500 v_PVOID_t pVosContext = NULL;
9501 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9502 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9503 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9504 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9506 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9507 if(NULL == wdiRSSIThresholdsInfo)
9508 {
9509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9510 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9511 VOS_ASSERT(0);
9512 return VOS_STATUS_E_NOMEM;
9513 }
9514 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9515 if(NULL == pWdaParams)
9516 {
9517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9518 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9519 VOS_ASSERT(0);
9520 vos_mem_free(wdiRSSIThresholdsInfo);
9521 return VOS_STATUS_E_NOMEM;
9522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9523 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9524 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9525 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9526 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9527 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9528 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9529 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9530 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9531 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9532 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9533 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9534 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9535 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9536 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9537
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9538 /* Store param pointer as passed in by caller */
9539 /* store Params pass it to WDI */
9540 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9541 pWdaParams->pWdaContext = pWDA;
9542 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9543 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9544 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9545 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9546 {
9547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9548 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9549 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9550 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9551 vos_mem_free(pWdaParams) ;
9552 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9553 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9554
9555}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9556/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9557 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9558 *
9559 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9560void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9561{
9562 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9563
9564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9565 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9566 if(NULL == pWdaParams)
9567 {
9568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9569 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9570 VOS_ASSERT(0) ;
9571 return ;
9572 }
9573
9574 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9575 vos_mem_free(pWdaParams->wdaMsgParam);
9576 vos_mem_free(pWdaParams) ;
9577
9578 //print a msg, nothing else to do
9579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9580 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9581 return ;
9582}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9583/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9584 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9585 * Free memory.
9586 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9587 */
9588void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9589{
9590 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9591
9592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9593 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9594
9595 if(NULL == pWdaParams)
9596 {
9597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9598 "%s: Invalid pWdaParams pointer", __func__);
9599 VOS_ASSERT(0);
9600 return;
9601 }
9602
9603 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9604 {
9605 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9606 vos_mem_free(pWdaParams->wdaMsgParam);
9607 vos_mem_free(pWdaParams);
9608 }
9609
9610 return;
9611}
9612/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 * FUNCTION: WDA_ProcessHostOffloadReq
9614 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9615 * to broadcast traffic (sta mode).
9616 */
9617VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9618 tSirHostOffloadReq *pHostOffloadParams)
9619{
9620 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9621 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9622 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9623 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9624 sizeof(WDI_HostOffloadReqParamsType)) ;
9625 tWDA_ReqParams *pWdaParams ;
9626
9627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9628 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629
9630 if(NULL == wdiHostOffloadInfo)
9631 {
9632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9633 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9634 VOS_ASSERT(0);
9635 return VOS_STATUS_E_NOMEM;
9636 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9637 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9638 if(NULL == pWdaParams)
9639 {
9640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9641 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9642 VOS_ASSERT(0);
9643 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9644 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9645 return VOS_STATUS_E_NOMEM;
9646 }
9647
9648 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9649 pHostOffloadParams->offloadType;
9650 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9651 pHostOffloadParams->enableOrDisable;
9652
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9653 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9654 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9655
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9656 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9657 {
9658 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9659 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9660 pHostOffloadParams->params.hostIpv4Addr,
9661 4);
9662 break;
9663 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9664 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9665 pHostOffloadParams->params.hostIpv6Addr,
9666 16);
9667 break;
9668 case SIR_IPV6_NS_OFFLOAD:
9669 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9670 pHostOffloadParams->params.hostIpv6Addr,
9671 16);
9672
9673#ifdef WLAN_NS_OFFLOAD
9674 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9675 {
9676 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9677 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9678 16);
9679 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9680 }
9681 else
9682 {
9683 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9684 }
9685
9686 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9687 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9688 16);
9689 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9690 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9691 6);
9692
9693 //Only two are supported so let's go through them without a loop
9694 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9695 {
9696 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9697 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9698 16);
9699 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9700 }
9701 else
9702 {
9703 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9704 }
9705
9706 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9707 {
9708 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9709 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9710 16);
9711 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9712 }
9713 else
9714 {
9715 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9716 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9717 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9718 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9719 break;
9720#endif //WLAN_NS_OFFLOAD
9721 default:
9722 {
9723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9724 "No Handling for Offload Type %x in WDA "
9725 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9726 //WDA_VOS_ASSERT(0) ;
9727 }
9728 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9729 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9730 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9731
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9732 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9733 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9734 /* store Params pass it to WDI */
9735 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9736 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9737
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9738
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9739 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9740 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9741
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9742 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9743 {
9744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9745 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9746 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9747 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9748 vos_mem_free(pWdaParams->wdaMsgParam);
9749 vos_mem_free(pWdaParams) ;
9750 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9751 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9752
9753}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9754/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9755 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9756 *
9757 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9758void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9759{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9760 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9761
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9763 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9764
9765 if(NULL == pWdaParams)
9766 {
9767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9768 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9769 VOS_ASSERT(0) ;
9770 return ;
9771 }
9772
9773 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9774 vos_mem_free(pWdaParams->wdaMsgParam);
9775 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9776
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9777 //print a msg, nothing else to do
9778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9779 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9780 return ;
9781}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9782/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9783 * FUNCTION: WDA_KeepAliveReqCallback
9784 * Free memory.
9785 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9786 */
9787void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9788{
9789 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9790
9791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9792 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9793
9794 if(NULL == pWdaParams)
9795 {
9796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9797 "%s: pWdaParams received NULL", __func__);
9798 VOS_ASSERT(0);
9799 return;
9800 }
9801
9802 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9803 {
9804 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9805 vos_mem_free(pWdaParams->wdaMsgParam);
9806 vos_mem_free(pWdaParams);
9807 }
9808
9809 return;
9810}
9811/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9812 * FUNCTION: WDA_ProcessKeepAliveReq
9813 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9814 * wakeup due to broadcast traffic (sta mode).
9815 */
9816VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9817 tSirKeepAliveReq *pKeepAliveParams)
9818{
9819 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9820 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9821 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9822 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9823 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9824 tWDA_ReqParams *pWdaParams;
9825
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9827 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9828 if(NULL == wdiKeepAliveInfo)
9829 {
9830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9831 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9832 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9833 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9834 return VOS_STATUS_E_NOMEM;
9835 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9836
9837 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9838 if(NULL == pWdaParams)
9839 {
9840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9841 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9842 VOS_ASSERT(0);
9843 vos_mem_free(wdiKeepAliveInfo);
9844 vos_mem_free(pKeepAliveParams);
9845 return VOS_STATUS_E_NOMEM;
9846 }
9847
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9848 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9849 pKeepAliveParams->packetType;
9850 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9851 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9852
9853 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9854 pKeepAliveParams->bssId,
9855 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9856
9857 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9858 {
9859 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9860 pKeepAliveParams->hostIpv4Addr,
9861 SIR_IPV4_ADDR_LEN);
9862 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9863 pKeepAliveParams->destIpv4Addr,
9864 SIR_IPV4_ADDR_LEN);
9865 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9866 pKeepAliveParams->destMacAddr,
9867 SIR_MAC_ADDR_LEN);
9868 }
9869 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9870 {
9871 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9872 SIR_IPV4_ADDR_LEN,
9873 0);
9874 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9875 SIR_IPV4_ADDR_LEN,
9876 0);
9877 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9878 SIR_MAC_ADDR_LEN,
9879 0);
9880 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9881 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9882 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9883
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9884 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9885 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9886 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9887 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9888 pWdaParams->pWdaContext = pWDA;
9889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9891 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9892 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9893 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9894 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9896 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9897 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9898 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9899 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9901 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9902 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9903 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9904 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9905 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9906 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9907 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9909 "TimePeriod %d PacketType %d",
9910 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9911 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9912 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9913 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9914
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9915 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9916 {
9917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9918 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9919 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9920 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9921 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9922 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9923 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9924 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9925
9926}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9927/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9928 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9929 *
9930 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9931void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9932 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9933 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9934{
9935 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9937 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9938 if(NULL == pWdaParams)
9939 {
9940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9941 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9942 VOS_ASSERT(0) ;
9943 return ;
9944 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9945 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9946 vos_mem_free(pWdaParams->wdaMsgParam);
9947 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9948 return ;
9949}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9950/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9951 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
9952 * Free memory.
9953 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
9954 */
9955void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9956{
9957 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9958
9959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9960 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9961
9962 if(NULL == pWdaParams)
9963 {
9964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9965 "%s: pWdaParams received NULL", __func__);
9966 VOS_ASSERT(0);
9967 return;
9968 }
9969
9970 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9971 {
9972 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9973 vos_mem_free(pWdaParams->wdaMsgParam);
9974 vos_mem_free(pWdaParams);
9975 }
9976
9977 return;
9978}
9979
9980/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9981 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
9982 * Request to WDI to add WOWL Bcast pattern
9983 */
9984VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
9985 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
9986{
9987 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9988 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9989 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
9990 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
9991 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
9992 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9994 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9995 if(NULL == wdiWowlAddBcPtrnInfo)
9996 {
9997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9998 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9999 VOS_ASSERT(0);
10000 return VOS_STATUS_E_NOMEM;
10001 }
10002 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10003 if(NULL == pWdaParams)
10004 {
10005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10006 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10007 VOS_ASSERT(0);
10008 vos_mem_free(wdiWowlAddBcPtrnInfo);
10009 return VOS_STATUS_E_NOMEM;
10010 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10011 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
10012 pWowlAddBcPtrnParams->ucPatternId;
10013 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
10014 pWowlAddBcPtrnParams->ucPatternByteOffset;
10015 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
10016 pWowlAddBcPtrnParams->ucPatternMaskSize;
10017 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
10018 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10019 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
10020 {
10021 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10022 pWowlAddBcPtrnParams->ucPattern,
10023 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
10024 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10025 pWowlAddBcPtrnParams->ucPatternMask,
10026 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
10027 }
10028 else
10029 {
10030 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10031 pWowlAddBcPtrnParams->ucPattern,
10032 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10033 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10034 pWowlAddBcPtrnParams->ucPatternMask,
10035 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10036
10037 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
10038 pWowlAddBcPtrnParams->ucPatternExt,
10039 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10040 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
10041 pWowlAddBcPtrnParams->ucPatternMaskExt,
10042 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10043 }
10044
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10045 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
10046 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
10047
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10048 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
10049 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10050 /* Store param pointer as passed in by caller */
10051 /* store Params pass it to WDI */
10052 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
10053 pWdaParams->pWdaContext = pWDA;
10054 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10055 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10056 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10057 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10058 {
10059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10060 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10061 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10062 vos_mem_free(pWdaParams->wdaMsgParam) ;
10063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10064 vos_mem_free(pWdaParams) ;
10065 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10066 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067
10068}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10069/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10070 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10071 *
10072 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10073void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10074 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
10075 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10076{
10077 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10079 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10080 if(NULL == pWdaParams)
10081 {
10082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10083 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10084 VOS_ASSERT(0) ;
10085 return ;
10086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10087 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10088 vos_mem_free(pWdaParams->wdaMsgParam);
10089 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10090 return ;
10091}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10092/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10093 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
10094 * Free memory.
10095 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
10096 */
10097void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10098{
10099 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10100
10101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10102 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10103
10104 if(NULL == pWdaParams)
10105 {
10106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10107 "%s: pWdaParams received NULL", __func__);
10108 VOS_ASSERT(0);
10109 return;
10110 }
10111
10112 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10113 {
10114 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10115 vos_mem_free(pWdaParams->wdaMsgParam);
10116 vos_mem_free(pWdaParams);
10117 }
10118
10119 return;
10120}
10121/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10122 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
10123 * Request to WDI to delete WOWL Bcast pattern
10124 */
10125VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
10126 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
10127{
10128 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10129 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10130 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
10131 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
10132 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
10133 tWDA_ReqParams *pWdaParams ;
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 == wdiWowlDelBcPtrnInfo)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10140 VOS_ASSERT(0);
10141 return VOS_STATUS_E_NOMEM;
10142 }
10143 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10144 if(NULL == pWdaParams)
10145 {
10146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10147 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10148 VOS_ASSERT(0);
10149 vos_mem_free(wdiWowlDelBcPtrnInfo);
10150 return VOS_STATUS_E_NOMEM;
10151 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10152 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
10153 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10154
10155 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
10156 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
10157
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10158 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
10159 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10160 /* Store param pointer as passed in by caller */
10161 /* store Params pass it to WDI */
10162 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
10163 pWdaParams->pWdaContext = pWDA;
10164 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10165 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10166 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10167 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10168 {
10169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10170 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10171 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10172 vos_mem_free(pWdaParams->wdaMsgParam) ;
10173 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10174 vos_mem_free(pWdaParams) ;
10175 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10176 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10177
10178}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10179/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10180 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10181 *
10182 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10183void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10184{
10185 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10186 tWDA_CbContext *pWDA;
10187 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10188 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10189 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10190 if(NULL == pWdaParams)
10191 {
10192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10193 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10194 VOS_ASSERT(0) ;
10195 return ;
10196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10197 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10198 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
10199
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10200 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
10201
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10202 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10203 vos_mem_free(pWdaParams) ;
10204
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10205 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10206 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10207 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10208 return ;
10209}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10210/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10211 * FUNCTION: WDA_WowlEnterReqCallback
10212 * Free memory and send WOWL Enter RSP back to PE.
10213 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
10214 */
10215void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
10216{
10217 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10218 tWDA_CbContext *pWDA;
10219 tSirHalWowlEnterParams *pWowlEnterParams;
10220
10221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10222 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10223
10224 if(NULL == pWdaParams)
10225 {
10226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10227 "%s: pWdaParams received NULL", __func__);
10228 VOS_ASSERT(0);
10229 return;
10230 }
10231
10232 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10233 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10234 pWowlEnterParams->status = wdiStatus;
10235
10236 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10237 {
10238 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10239 vos_mem_free(pWdaParams);
10240 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10241 }
10242
10243 return;
10244}
10245/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10246 * FUNCTION: WDA_ProcessWowlEnterReq
10247 * Request to WDI to enter WOWL
10248 */
10249VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10250 tSirHalWowlEnterParams *pWowlEnterParams)
10251{
10252 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10253 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10254 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10255 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10256 sizeof(WDI_WowlEnterReqParamsType)) ;
10257 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10259 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10260 if(NULL == wdiWowlEnterInfo)
10261 {
10262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10263 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10264 VOS_ASSERT(0);
10265 return VOS_STATUS_E_NOMEM;
10266 }
10267 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10268 if(NULL == pWdaParams)
10269 {
10270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10271 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10272 VOS_ASSERT(0);
10273 vos_mem_free(wdiWowlEnterInfo);
10274 return VOS_STATUS_E_NOMEM;
10275 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10276
10277 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10278
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10279 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10280 pWowlEnterParams->magicPtrn,
10281 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10282 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10283 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10284 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10285 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10286 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10287 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10288 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10289 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10290 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10291 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10292 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10293 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10294 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10295 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10296 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10297 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10298#ifdef WLAN_WAKEUP_EVENTS
10299 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10300 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10301
10302 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10303 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10304
10305 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10306 pWowlEnterParams->ucWowNetScanOffloadMatch;
10307
10308 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10309 pWowlEnterParams->ucWowGTKRekeyError;
10310
10311 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10312 pWowlEnterParams->ucWoWBSSConnLoss;
10313#endif // WLAN_WAKEUP_EVENTS
10314
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10315 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10316 pWowlEnterParams->bssIdx;
10317
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10318 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10319 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10320 /* Store param pointer as passed in by caller */
10321 /* store Params pass it to WDI */
10322 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10323 pWdaParams->pWdaContext = pWDA;
10324 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10325 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10326 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10327 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10328 {
10329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10330 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10331 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10332 vos_mem_free(pWdaParams->wdaMsgParam) ;
10333 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10334 vos_mem_free(pWdaParams) ;
10335 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10336 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10337
10338}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10339/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10340 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10341 *
10342 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10343void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10344{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10345 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10346 tWDA_CbContext *pWDA;
10347 tSirHalWowlExitParams *pWowlExitParams;
10348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10349 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10350 if(NULL == pWdaParams)
10351 {
10352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10353 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10354 VOS_ASSERT(0) ;
10355 return ;
10356 }
10357 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10358 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10359
10360 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10361 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10362
10363 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10364 vos_mem_free(pWdaParams) ;
10365
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10367 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10368 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10369 return ;
10370}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10371/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10372 * FUNCTION: WDA_WowlExitReqCallback
10373 * Free memory and send WOWL Exit RSP back to PE.
10374 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10375 */
10376void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10377{
10378 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10379 tWDA_CbContext *pWDA;
10380 tSirHalWowlExitParams *pWowlExitParams;
10381
10382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10383 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10384
10385 if(NULL == pWdaParams)
10386 {
10387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10388 "%s: pWdaParams received NULL", __func__);
10389 VOS_ASSERT(0);
10390 return;
10391 }
10392
10393 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10394 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10395 pWowlExitParams->status = wdiStatus;
10396
10397 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10398 {
10399 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10400 vos_mem_free(pWdaParams);
10401 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10402 }
10403
10404 return;
10405}
10406/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10407 * FUNCTION: WDA_ProcessWowlExitReq
10408 * Request to WDI to add WOWL Bcast pattern
10409 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10410VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10411 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10412{
10413 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10414 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10415 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10416 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10417 sizeof(WDI_WowlExitReqParamsType)) ;
10418 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10420 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10421 if(NULL == wdiWowlExitInfo)
10422 {
10423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10424 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10425 VOS_ASSERT(0);
10426 return VOS_STATUS_E_NOMEM;
10427 }
10428 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10429 if(NULL == pWdaParams)
10430 {
10431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10432 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10433 VOS_ASSERT(0);
10434 vos_mem_free(wdiWowlExitInfo);
10435 return VOS_STATUS_E_NOMEM;
10436 }
10437
10438 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10439 pWowlExitParams->bssIdx;
10440
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10441 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10442 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10443
10444 /* Store param pointer as passed in by caller */
10445 /* store Params pass it to WDI */
10446 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10447 pWdaParams->pWdaContext = pWDA;
10448 pWdaParams->wdaMsgParam = pWowlExitParams;
10449
10450 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10451 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10452
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10453 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10454 {
10455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10456 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10457 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10458 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10459 vos_mem_free(pWdaParams->wdaMsgParam);
10460 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10461 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10462 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10463}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10464/*
10465 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10466 * Request to WDI to determine whether a given station is capable of
10467 * using HW-based frame translation
10468 */
10469v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10470 tANI_U8 staIdx)
10471{
10472 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10473}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10474
10475/*
10476 * FUNCTION: WDA_IsSelfSTA
10477 * Request to WDI to determine whether a given STAID is self station
10478 * index.
10479 */
10480v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10481{
10482
10483 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10484
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10485 if (NULL != pWDA)
10486 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10487 else
10488 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10489}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10490/*
10491 * FUNCTION: WDA_NvDownloadReqCallback
10492 * send NV Download RSP back to PE
10493 */
10494void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10495 void* pUserData)
10496{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10497
10498 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10499 tWDA_CbContext *pWDA;
10500
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10502 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10503
10504 if(NULL == pWdaParams)
10505 {
10506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10507 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10508 VOS_ASSERT(0) ;
10509 return ;
10510 }
10511
10512 pWDA = pWdaParams->pWdaContext;
10513
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10514 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10515 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10516 vos_mem_free(pWdaParams);
10517
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10518 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10519 return ;
10520}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10521/*
10522 * FUNCTION: WDA_ProcessNvDownloadReq
10523 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10524 */
10525VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10526{
10527 /* Initialize the local Variables*/
10528 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10529 v_VOID_t *pNvBuffer=NULL;
10530 v_SIZE_t bufferSize = 0;
10531 WDI_Status status = WDI_STATUS_E_FAILURE;
10532 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10533 tWDA_ReqParams *pWdaParams ;
10534
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10536 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10537 if(NULL == pWDA)
10538 {
10539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10540 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10541 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10542 return VOS_STATUS_E_FAILURE;
10543 }
10544
10545 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10546 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10547
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10548 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10549 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10550 if(NULL == wdiNvDownloadReqParam)
10551 {
10552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10553 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10554 VOS_ASSERT(0);
10555 return VOS_STATUS_E_NOMEM;
10556 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10557 /* Copy Params to wdiNvDownloadReqParam*/
10558 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10559 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10560
10561 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10562 if(NULL == pWdaParams)
10563 {
10564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10565 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10566 VOS_ASSERT(0);
10567 vos_mem_free(wdiNvDownloadReqParam);
10568 return VOS_STATUS_E_NOMEM;
10569 }
10570
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10571 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10572 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10573 pWdaParams->wdaMsgParam = NULL;
10574 pWdaParams->pWdaContext = pWDA;
10575
10576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10577 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10578
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10579 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10580 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10581
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10582 if(IS_WDI_STATUS_FAILURE(status))
10583 {
10584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10585 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10586 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10587 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10588 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10589 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10590}
10591/*
10592 * FUNCTION: WDA_FlushAcReqCallback
10593 * send Flush AC RSP back to TL
10594 */
10595void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10596{
10597 vos_msg_t wdaMsg = {0} ;
10598 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10599 tFlushACReq *pFlushACReqParams;
10600 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10602 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10603 if(NULL == pWdaParams)
10604 {
10605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10606 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10607 VOS_ASSERT(0) ;
10608 return ;
10609 }
10610
10611 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10612 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10613 if(NULL == pFlushACRspParams)
10614 {
10615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10616 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10617 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10618 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10619 return ;
10620 }
10621 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10622 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10623 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10624 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10625 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10626 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10627 vos_mem_free(pWdaParams->wdaMsgParam) ;
10628 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10629 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10630 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10631 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10632 // POST message to TL
10633 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10634
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10635 return ;
10636}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10637/*
10638 * FUNCTION: WDA_ProcessFlushAcReq
10639 * Request to WDI to Update the DELBA REQ params.
10640 */
10641VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10642 tFlushACReq *pFlushAcReqParams)
10643{
10644 WDI_Status status = WDI_STATUS_SUCCESS ;
10645 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10646 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10647 sizeof(WDI_FlushAcReqParamsType)) ;
10648 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10649 if(NULL == wdiFlushAcReqParam)
10650 {
10651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10652 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10653 VOS_ASSERT(0);
10654 return VOS_STATUS_E_NOMEM;
10655 }
10656 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10657 if(NULL == pWdaParams)
10658 {
10659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10660 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10661 VOS_ASSERT(0);
10662 vos_mem_free(wdiFlushAcReqParam);
10663 return VOS_STATUS_E_NOMEM;
10664 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10666 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10667 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10668 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10669 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10670 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10671 /* Store Flush AC pointer, as this will be used for response */
10672 /* store Params pass it to WDI */
10673 pWdaParams->pWdaContext = pWDA;
10674 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10675 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10676 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10677 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10678 if(IS_WDI_STATUS_FAILURE(status))
10679 {
10680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10681 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10682 vos_mem_free(pWdaParams->wdaMsgParam) ;
10683 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10684 vos_mem_free(pWdaParams) ;
10685 //TODO: respond to TL with failure
10686 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10687 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10688}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10689/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10690 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10691 *
10692 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10693void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10694{
10695 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10696 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10697 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10698
10699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10700 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10701 if(NULL == pWdaParams)
10702 {
10703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10704 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10705 VOS_ASSERT(0) ;
10706 return ;
10707 }
10708 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10709 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10710 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10711 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10712 {
10713 pWDA->wdaAmpSessionOn = VOS_FALSE;
10714 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10715 vos_mem_free(pWdaParams->wdaMsgParam) ;
10716 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10717 vos_mem_free(pWdaParams) ;
10718 /*
10719 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10720 * param here
10721 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10722 return ;
10723}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10724/*
10725 * FUNCTION: WDA_BtAmpEventReqCallback
10726 * Free memory.
10727 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10728 */
10729void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10730{
10731 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10732 tWDA_CbContext *pWDA;
10733 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10734
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10736 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10737
10738 if(NULL == pWdaParams)
10739 {
10740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10741 "%s: pWdaParams received NULL", __func__);
10742 VOS_ASSERT(0);
10743 return;
10744 }
10745
10746 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10747 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10748
10749 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10750 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10751 {
10752 pWDA->wdaAmpSessionOn = VOS_FALSE;
10753 }
10754
10755 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10756 {
10757 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10758 vos_mem_free(pWdaParams->wdaMsgParam);
10759 vos_mem_free(pWdaParams);
10760 }
10761
10762 return;
10763}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10764/*
10765 * FUNCTION: WDA_ProcessBtAmpEventReq
10766 * Request to WDI to Update with BT AMP events.
10767 */
10768VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10769 tSmeBtAmpEvent *pBtAmpEventParams)
10770{
10771 WDI_Status status = WDI_STATUS_SUCCESS ;
10772 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10773 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10774 sizeof(WDI_BtAmpEventParamsType)) ;
10775 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10777 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10778 if(NULL == wdiBtAmpEventParam)
10779 {
10780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10781 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10782 VOS_ASSERT(0);
10783 return VOS_STATUS_E_NOMEM;
10784 }
10785 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10786 if(NULL == pWdaParams)
10787 {
10788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10789 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10790 VOS_ASSERT(0);
10791 vos_mem_free(wdiBtAmpEventParam);
10792 return VOS_STATUS_E_NOMEM;
10793 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10794 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10795 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10796 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10797 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10798 /* Store BT AMP event pointer, as this will be used for response */
10799 /* store Params pass it to WDI */
10800 pWdaParams->pWdaContext = pWDA;
10801 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10802 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10803 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10804 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10805 if(IS_WDI_STATUS_FAILURE(status))
10806 {
10807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10808 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10809 vos_mem_free(pWdaParams->wdaMsgParam) ;
10810 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10811 vos_mem_free(pWdaParams) ;
10812 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10813 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10814 {
10815 pWDA->wdaAmpSessionOn = VOS_TRUE;
10816 }
10817 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10818}
10819
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10820/*
10821 * FUNCTION: WDA_FTMCommandReqCallback
10822 * Handle FTM CMD response came from HAL
10823 * Route responce to HDD FTM
10824 */
10825void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10826 void *usrData)
10827{
10828 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10829 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10830 {
10831 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10832 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10833 return;
10834 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10835 /* Release Current FTM Command Request */
10836 vos_mem_free(pWDA->wdaFTMCmdReq);
10837 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10838 /* Post FTM Responce to HDD FTM */
10839 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10840 return;
10841}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10842/*
10843 * FUNCTION: WDA_ProcessFTMCommand
10844 * Send FTM command to WDI
10845 */
10846VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10847 tPttMsgbuffer *pPTTFtmCmd)
10848{
10849 WDI_Status status = WDI_STATUS_SUCCESS;
10850 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10851 ftmCMDReq = (WDI_FTMCommandReqType *)
10852 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10853 if(NULL == ftmCMDReq)
10854 {
10855 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10856 "WDA FTM Command buffer alloc fail");
10857 return VOS_STATUS_E_NOMEM;
10858 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10859 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10860 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10862 /* Send command to WDI */
10863 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10864 return status;
10865}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10866#ifdef FEATURE_OEM_DATA_SUPPORT
10867/*
10868 * FUNCTION: WDA_StartOemDataReqCallback
10869 *
10870 */
10871void WDA_StartOemDataReqCallback(
10872 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10873 void* pUserData)
10874{
10875 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10876 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10877 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10878 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10879
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10881 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10882
10883 if(NULL == pWdaParams)
10884 {
10885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10886 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10887 VOS_ASSERT(0) ;
10888 return ;
10889 }
10890 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10891
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10892 if(NULL == pWDA)
10893 {
10894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10895 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10896 VOS_ASSERT(0);
10897 return ;
10898 }
10899
10900 /*
10901 * Allocate memory for response params sent to PE
10902 */
10903 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10904
10905 // Check if memory is allocated for OemdataMeasRsp Params.
10906 if(NULL == pOemDataRspParams)
10907 {
10908 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10909 "OEM DATA WDA callback alloc fail");
10910 VOS_ASSERT(0) ;
10911 return;
10912 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10913
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10914 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10915 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10916 vos_mem_free(pWdaParams->wdaMsgParam);
10917 vos_mem_free(pWdaParams) ;
10918
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10919 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10920 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10921 * Also, here success always means that we have atleast one BSSID.
10922 */
10923 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10924
10925 //enable Tx
10926 status = WDA_ResumeDataTx(pWDA);
10927 if(status != VOS_STATUS_SUCCESS)
10928 {
10929 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10930 }
10931 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10932 return ;
10933}
10934/*
10935 * FUNCTION: WDA_ProcessStartOemDataReq
10936 * Send Start Oem Data Req to WDI
10937 */
10938VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10939 tStartOemDataReq *pOemDataReqParams)
10940{
10941 WDI_Status status = WDI_STATUS_SUCCESS;
10942 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10943 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10944
10945 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
10946
10947 if(NULL == wdiOemDataReqParams)
10948 {
10949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10950 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10951 VOS_ASSERT(0);
10952 return VOS_STATUS_E_NOMEM;
10953 }
10954
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10955 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
10956 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
10957 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
10958 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10959
10960 wdiOemDataReqParams->wdiReqStatusCB = NULL;
10961
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10962 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10963 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10964 {
10965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10966 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10967 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10968 vos_mem_free(pOemDataReqParams);
10969 VOS_ASSERT(0);
10970 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10971 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10972
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]10973 pWdaParams->pWdaContext = (void*)pWDA;
10974 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
10975 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10976
10977 status = WDI_StartOemDataReq(wdiOemDataReqParams,
10978 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10979
10980 if(IS_WDI_STATUS_FAILURE(status))
10981 {
10982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10983 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10984 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10985 vos_mem_free(pWdaParams->wdaMsgParam);
10986 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10987 }
10988 return CONVERT_WDI2VOS_STATUS(status) ;
10989}
10990#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10991/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10992 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10993 *
10994 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10995void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10996{
10997 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10999 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11000 if(NULL == pWdaParams)
11001 {
11002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11003 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11004 VOS_ASSERT(0) ;
11005 return ;
11006 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11007
11008 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11009 vos_mem_free(pWdaParams->wdaMsgParam);
11010 vos_mem_free(pWdaParams);
11011
11012 return ;
11013}
11014/*
11015 * FUNCTION: WDA_SetTxPerTrackingReqCallback
11016 * Free memory.
11017 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
11018 */
11019void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
11020{
11021 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11022
11023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11024 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11025
11026 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11027 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11029 "%s: pWdaParams received NULL", __func__);
11030 VOS_ASSERT(0);
11031 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11032 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11033
11034 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11035 {
11036 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11037 vos_mem_free(pWdaParams->wdaMsgParam);
11038 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11039 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11040
11041 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11042}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11043#ifdef WLAN_FEATURE_GTK_OFFLOAD
11044/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11045 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11046 *
11047 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11048void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11049 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11050{
11051 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11052
11053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11054 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11055 if(NULL == pWdaParams)
11056 {
11057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11058 "%s: pWdaParams received NULL", __func__);
11059 VOS_ASSERT(0);
11060 return;
11061 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11062
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11063 vos_mem_free(pWdaParams->wdaMsgParam) ;
11064 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11065 vos_mem_free(pWdaParams) ;
11066
11067 //print a msg, nothing else to do
11068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11069 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11070
11071 return ;
11072}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11073/*
11074 * FUNCTION: WDA_GTKOffloadReqCallback
11075 * Free memory.
11076 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
11077 */
11078void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11079{
11080 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11081
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11083 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11084
11085 if(NULL == pWdaParams)
11086 {
11087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11088 "%s: pWdaParams received NULL", __func__);
11089 VOS_ASSERT(0);
11090 return;
11091 }
11092
11093 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11094 {
11095 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11096 vos_mem_free(pWdaParams->wdaMsgParam);
11097 vos_mem_free(pWdaParams);
11098 }
11099
11100 return;
11101}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11102/*
11103 * FUNCTION: WDA_ProcessGTKOffloadReq
11104 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11105 * to broadcast traffic (sta mode).
11106 */
11107VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
11108 tpSirGtkOffloadParams pGtkOffloadParams)
11109{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11110 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11111 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
11112 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
11113 sizeof(WDI_GtkOffloadReqMsg)) ;
11114 tWDA_ReqParams *pWdaParams ;
11115
11116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11117 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11118
11119 if(NULL == wdiGtkOffloadReqMsg)
11120 {
11121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11122 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11123 VOS_ASSERT(0);
11124 return VOS_STATUS_E_NOMEM;
11125 }
11126
11127 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11128 if(NULL == pWdaParams)
11129 {
11130 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11131 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11132 VOS_ASSERT(0);
11133 vos_mem_free(wdiGtkOffloadReqMsg);
11134 return VOS_STATUS_E_NOMEM;
11135 }
11136
11137 //
11138 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
11139 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11140
11141 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11142 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11143
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11144 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
11145 // Copy KCK
11146 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
11147 // Copy KEK
11148 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
11149 // Copy KeyReplayCounter
11150 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
11151 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
11152
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11153 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
11154 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11155
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11156
11157 /* Store Params pass it to WDI */
11158 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
11159 pWdaParams->pWdaContext = pWDA;
11160 /* Store param pointer as passed in by caller */
11161 pWdaParams->wdaMsgParam = pGtkOffloadParams;
11162
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11163 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11164
11165 if(IS_WDI_STATUS_FAILURE(status))
11166 {
11167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11168 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
11169 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11170 vos_mem_free(pWdaParams->wdaMsgParam);
11171 vos_mem_free(pWdaParams);
11172 }
11173
11174 return CONVERT_WDI2VOS_STATUS(status) ;
11175}
11176
11177/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11178 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11179 *
11180 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11181void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11182 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11183{
11184 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11185 tWDA_CbContext *pWDA;
11186 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11187 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11188 vos_msg_t vosMsg;
11189
11190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11191 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11192
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11193 if(NULL == pWdaParams)
11194 {
11195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11196 "%s: pWdaParams received NULL", __func__);
11197 VOS_ASSERT(0);
11198 return;
11199 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11200
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11201 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
11202 if(NULL == pGtkOffloadGetInfoRsp)
11203 {
11204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11205 "%s: vos_mem_malloc failed ", __func__);
11206 VOS_ASSERT(0);
11207 return;
11208 }
11209
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11210 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
11211 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
11212
11213 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
11214 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
11215
11216 /* Message Header */
11217 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]11218 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11219
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11220 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
11221 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
11222 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
11223 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
11224 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11225
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11226 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11227 pwdiGtkOffloadGetInfoRsparams->bssId,
11228 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11229 /* VOS message wrapper */
11230 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11231 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11232 vosMsg.bodyval = 0;
11233
11234 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11235 {
11236 /* free the mem and return */
11237 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11238 }
11239
11240 vos_mem_free(pWdaParams->wdaMsgParam) ;
11241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11242 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11243
11244 return;
11245}
11246/*
11247 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11248 * Free memory and send RSP back to SME.
11249 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11250 */
11251void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11252{
11253 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11254 vos_msg_t vosMsg;
11255
11256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11257 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11258
11259 if(NULL == pWdaParams)
11260 {
11261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11262 "%s: pWdaParams received NULL", __func__);
11263 VOS_ASSERT(0);
11264 return;
11265 }
11266
11267 /* VOS message wrapper */
11268 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11269 vosMsg.bodyptr = NULL;
11270 vosMsg.bodyval = 0;
11271
11272 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11273 {
11274 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11275 vos_mem_free(pWdaParams->wdaMsgParam);
11276 vos_mem_free(pWdaParams);
11277 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11278 }
11279
11280 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11281}
11282#endif
11283
11284/*
11285 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11286 * Request to WDI to set Tx Per Tracking configurations
11287 */
11288VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11289{
11290 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11291 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11292 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11293 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11294 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11295 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11297 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11298 if(NULL == pwdiSetTxPerTrackingReqParams)
11299 {
11300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11301 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11302 vos_mem_free(pTxPerTrackingParams);
11303 VOS_ASSERT(0);
11304 return VOS_STATUS_E_NOMEM;
11305 }
11306 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11307 if(NULL == pWdaParams)
11308 {
11309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11310 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11311 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11312 vos_mem_free(pTxPerTrackingParams);
11313 VOS_ASSERT(0);
11314 return VOS_STATUS_E_NOMEM;
11315 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11316 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11317 pTxPerTrackingParams->ucTxPerTrackingEnable;
11318 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11319 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11320 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11321 pTxPerTrackingParams->ucTxPerTrackingRatio;
11322 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11323 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11324 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11325 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11326 /* Store param pointer as passed in by caller */
11327 /* store Params pass it to WDI
11328 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11329 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11330 pWdaParams->pWdaContext = pWDA;
11331 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11332 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11333 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11334 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11335 {
11336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11337 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11338 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11339 vos_mem_free(pWdaParams->wdaMsgParam) ;
11340 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11341 vos_mem_free(pWdaParams) ;
11342 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11343 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11344
11345}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11346/*
11347 * FUNCTION: WDA_HALDumpCmdCallback
11348 * Send the VOS complete .
11349 */
11350void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11351 void* pUserData)
11352{
11353 tANI_U8 *buffer = NULL;
11354 tWDA_CbContext *pWDA = NULL;
11355 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11356 if(NULL == pWdaParams)
11357 {
11358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11359 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11360 VOS_ASSERT(0) ;
11361 return ;
11362 }
11363
11364 pWDA = pWdaParams->pWdaContext;
11365 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11366 if(wdiRspParams->usBufferLen > 0)
11367 {
11368 /*Copy the Resp data to UMAC supplied buffer*/
11369 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11371 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11372 vos_mem_free(pWdaParams);
11373
11374 /* Indicate VOSS about the start complete */
11375 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11376 return ;
11377}
11378
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11379/*
11380 * FUNCTION: WDA_ProcessHALDumpCmdReq
11381 * Send Dump command to WDI
11382 */
11383VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11384 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11385 tANI_U32 arg4, tANI_U8 *pBuffer)
11386{
11387 WDI_Status status = WDI_STATUS_SUCCESS;
11388 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11389 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11390 tWDA_ReqParams *pWdaParams ;
11391 pVosContextType pVosContext = NULL;
11392 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11393 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11394 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11395 if(pVosContext)
11396 {
11397 if (pVosContext->isLogpInProgress)
11398 {
11399 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11400 "%s:LOGP in Progress. Ignore!!!", __func__);
11401 return VOS_STATUS_E_BUSY;
11402 }
11403 }
11404 else
11405 {
11406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11407 "%s: VOS Context Null", __func__);
11408 return VOS_STATUS_E_RESOURCES;
11409 }
11410
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11411 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11416 return VOS_STATUS_E_NOMEM;
11417 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11418 /* Allocate memory WDI request structure*/
11419 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11420 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11421 if(NULL == wdiHALDumpCmdReqParam)
11422 {
11423 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11424 "WDA HAL DUMP Command buffer alloc fail");
11425 vos_mem_free(pWdaParams);
11426 return WDI_STATUS_E_FAILURE;
11427 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11428 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11429 /* Extract the arguments */
11430 wdiHalDumpCmdInfo->command = cmd;
11431 wdiHalDumpCmdInfo->argument1 = arg1;
11432 wdiHalDumpCmdInfo->argument2 = arg2;
11433 wdiHalDumpCmdInfo->argument3 = arg3;
11434 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11435 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11436 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11437
11438 /* Response message will be passed through the buffer */
11439 pWdaParams->wdaMsgParam = (void *)pBuffer;
11440
11441 /* store Params pass it to WDI */
11442 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11443 /* Send command to WDI */
11444 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11445 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11446 if ( vStatus != VOS_STATUS_SUCCESS )
11447 {
11448 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11449 {
11450 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11451 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11452 }
11453 else
11454 {
11455 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11456 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11457 }
11458 VOS_ASSERT(0);
11459 }
11460 return status;
11461}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11462#ifdef WLAN_FEATURE_GTK_OFFLOAD
11463/*
11464 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11465 * Request to WDI to get GTK Offload Information
11466 */
11467VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11468 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11469{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11470 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11471 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11472 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11473 tWDA_ReqParams *pWdaParams ;
11474
11475 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11476 {
11477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11478 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11479 VOS_ASSERT(0);
11480 return VOS_STATUS_E_NOMEM;
11481 }
11482
11483 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11484 if(NULL == pWdaParams)
11485 {
11486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11487 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11488 VOS_ASSERT(0);
11489 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11490 return VOS_STATUS_E_NOMEM;
11491 }
11492
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11493 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11494 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11495
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11496 /* Store Params pass it to WDI */
11497 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11498 pWdaParams->pWdaContext = pWDA;
11499 /* Store param pointer as passed in by caller */
11500 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11501
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11502 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11503 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11504
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11505 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11506
11507 if(IS_WDI_STATUS_FAILURE(status))
11508 {
11509 /* failure returned by WDI API */
11510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11511 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11512 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11513 vos_mem_free(pWdaParams) ;
11514 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11515 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11516 }
11517
11518 return CONVERT_WDI2VOS_STATUS(status) ;
11519}
11520#endif // WLAN_FEATURE_GTK_OFFLOAD
11521
11522/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11523 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11524 *
11525 */
11526VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11527 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11528{
11529 WDI_Status wdiStatus;
11530 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11531
11532 addPeriodicTxPtrnParams =
11533 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11534
11535 if (NULL == addPeriodicTxPtrnParams)
11536 {
11537 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11538 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11539 __func__);
11540
11541 return VOS_STATUS_E_NOMEM;
11542 }
11543
11544 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11545 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11546
11547 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11548 addPeriodicTxPtrnParams->pUserData = pWDA;
11549
11550 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11551
11552 if (WDI_STATUS_PENDING == wdiStatus)
11553 {
11554 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11555 "Pending received for %s:%d", __func__, __LINE__ );
11556 }
11557 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11558 {
11559 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11560 "Failure in %s:%d", __func__, __LINE__ );
11561 }
11562
11563 vos_mem_free(addPeriodicTxPtrnParams);
11564
11565 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11566}
11567
11568/*
11569 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11570 *
11571 */
11572VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11573 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11574{
11575 WDI_Status wdiStatus;
11576 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11577
11578 delPeriodicTxPtrnParams =
11579 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11580
11581 if (NULL == delPeriodicTxPtrnParams)
11582 {
11583 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11584 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11585 __func__);
11586
11587 return VOS_STATUS_E_NOMEM;
11588 }
11589
11590 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11591 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11592
11593 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11594 delPeriodicTxPtrnParams->pUserData = pWDA;
11595
11596 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11597
11598 if (WDI_STATUS_PENDING == wdiStatus)
11599 {
11600 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11601 "Pending received for %s:%d", __func__, __LINE__ );
11602 }
11603 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11604 {
11605 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11606 "Failure in %s:%d", __func__, __LINE__ );
11607 }
11608
11609 vos_mem_free(delPeriodicTxPtrnParams);
11610
11611 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11612}
11613
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11614#ifdef FEATURE_WLAN_BATCH_SCAN
11615/*
11616 * FUNCTION: WDA_ProcessStopBatchScanInd
11617 *
11618 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11619 *
11620 * PARAM:
11621 * pWDA: pointer to WDA context
11622 * pReq: pointer to stop batch scan request
11623 */
11624VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11625 tSirStopBatchScanInd *pReq)
11626{
11627 WDI_Status wdiStatus;
11628 WDI_StopBatchScanIndType wdiReq;
11629
11630 wdiReq.param = pReq->param;
11631
11632 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11633
11634 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11635 {
11636 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11637 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11638 }
11639
11640 vos_mem_free(pReq);
11641
11642 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11643}
11644/*==========================================================================
11645 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11646
11647 DESCRIPTION
11648 API to pull batch scan result from FW
11649
11650 PARAMETERS
11651 pWDA: Pointer to WDA context
11652 pGetBatchScanReq: Pointer to get batch scan result indication
11653
11654 RETURN VALUE
11655 NONE
11656
11657===========================================================================*/
11658VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11659 tSirTriggerBatchScanResultInd *pReq)
11660{
11661 WDI_Status wdiStatus;
11662 WDI_TriggerBatchScanResultIndType wdiReq;
11663
11664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11665 "------> %s " ,__func__);
11666
11667 wdiReq.param = pReq->param;
11668
11669 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11670
11671 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11672 {
11673 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11674 "Trigger batch scan result ind failed %s:%d",
11675 __func__, wdiStatus);
11676 }
11677
11678 vos_mem_free(pReq);
11679
11680 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11681}
11682
11683/*==========================================================================
11684 FUNCTION WDA_SetBatchScanRespCallback
11685
11686 DESCRIPTION
11687 API to process set batch scan response from FW
11688
11689 PARAMETERS
11690 pRsp: Pointer to set batch scan response
11691 pUserData: Pointer to user data
11692
11693 RETURN VALUE
11694 NONE
11695
11696===========================================================================*/
11697void WDA_SetBatchScanRespCallback
11698(
11699 WDI_SetBatchScanRspType *pRsp,
11700 void* pUserData
11701)
11702{
11703 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11704 tpAniSirGlobal pMac;
11705 void *pCallbackContext;
11706 tWDA_CbContext *pWDA = NULL ;
11707 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11708
11709
11710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11711 "<------ %s " ,__func__);
11712 if (NULL == pWdaParams)
11713 {
11714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11715 "%s: pWdaParams received NULL", __func__);
11716 VOS_ASSERT(0) ;
11717 return ;
11718 }
11719
11720 /*extract WDA context*/
11721 pWDA = pWdaParams->pWdaContext;
11722 if (NULL == pWDA)
11723 {
11724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11725 "%s:pWDA is NULL can't invole HDD callback",
11726 __func__);
11727 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11728 vos_mem_free(pWdaParams->wdaMsgParam);
11729 vos_mem_free(pWdaParams);
11730 VOS_ASSERT(0);
11731 return;
11732 }
11733
11734 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11735 vos_mem_free(pWdaParams->wdaMsgParam);
11736 vos_mem_free(pWdaParams);
11737
11738 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11739 if (NULL == pMac)
11740 {
11741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11742 "%s:pMac is NULL", __func__);
11743 VOS_ASSERT(0);
11744 return;
11745 }
11746
11747 pHddSetBatchScanRsp =
11748 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11749 if (NULL == pHddSetBatchScanRsp)
11750 {
11751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11752 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11753 VOS_ASSERT(0);
11754 return;
11755 }
11756
11757 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11758
11759 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11760 /*call hdd callback with set batch scan response data*/
11761 if(pMac->pmc.setBatchScanReqCallback)
11762 {
11763 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11764 }
11765 else
11766 {
11767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11768 "%s:HDD callback is null", __func__);
11769 VOS_ASSERT(0);
11770 }
11771
11772 vos_mem_free(pHddSetBatchScanRsp);
11773 return ;
11774}
11775
11776/*==========================================================================
11777 FUNCTION WDA_ProcessSetBatchScanReq
11778
11779 DESCRIPTION
11780 API to send set batch scan request to WDI
11781
11782 PARAMETERS
11783 pWDA: Pointer to WDA context
11784 pSetBatchScanReq: Pointer to set batch scan req
11785
11786 RETURN VALUE
11787 NONE
11788
11789===========================================================================*/
11790VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11791 tSirSetBatchScanReq *pSetBatchScanReq)
11792{
11793 WDI_Status status;
11794 tWDA_ReqParams *pWdaParams ;
11795 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11796
11797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11798 "------> %s " ,__func__);
11799
11800 pWdiSetBatchScanReq =
11801 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11802 if (NULL == pWdiSetBatchScanReq)
11803 {
11804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11805 "%s: VOS MEM Alloc Failure", __func__);
11806 vos_mem_free(pSetBatchScanReq);
11807 VOS_ASSERT(0);
11808 return VOS_STATUS_E_NOMEM;
11809 }
11810
11811 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11812 if (NULL == pWdaParams)
11813 {
11814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11815 "%s: VOS MEM Alloc Failure", __func__);
11816 VOS_ASSERT(0);
11817 vos_mem_free(pSetBatchScanReq);
11818 vos_mem_free(pWdiSetBatchScanReq);
11819 return VOS_STATUS_E_NOMEM;
11820 }
11821
11822 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11823 pWdiSetBatchScanReq->numberOfScansToBatch =
11824 pSetBatchScanReq->numberOfScansToBatch;
11825 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11826 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11827 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11828
11829 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11830 pWdaParams->pWdaContext = pWDA;
11831 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11832
11833 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11834 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11835 if (IS_WDI_STATUS_FAILURE(status))
11836 {
11837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11838 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11839 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11840 vos_mem_free(pWdaParams->wdaMsgParam);
11841 vos_mem_free(pWdaParams);
11842 }
11843 return CONVERT_WDI2VOS_STATUS(status);
11844}
11845
11846#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11847/*
11848 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11849 *
11850 * DESCRIPTION: This function sends start/update OBSS scan
11851 * inidcation message to WDI
11852 *
11853 * PARAM:
11854 * pWDA: pointer to WDA context
11855 * pReq: pointer to start OBSS scan request
11856 */
11857VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11858 tSirHT40OBSSScanInd *pReq)
11859{
11860 WDI_Status status;
11861 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11862 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11863
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11865 "------> %s " ,__func__);
11866 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11867 wdiOBSSScanParams.pUserData = pWDA;
11868
11869 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11870 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11871 pWdiOBSSScanInd->scanType = pReq->scanType;
11872 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11873 pReq->OBSSScanActiveDwellTime;
11874 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11875 pReq->OBSSScanPassiveDwellTime;
11876 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11877 pReq->BSSChannelWidthTriggerScanInterval;
11878 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11879 pReq->BSSWidthChannelTransitionDelayFactor;
11880 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11881 pReq->OBSSScanActiveTotalPerChannel;
11882 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11883 pReq->OBSSScanPassiveTotalPerChannel;
11884 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11885 pReq->OBSSScanActivityThreshold;
11886 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11887 vos_mem_copy(pWdiOBSSScanInd->channels,
11888 pReq->channels,
11889 pReq->channelCount);
11890 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11891 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11892 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11893 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11894 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11895
11896 vos_mem_copy(pWdiOBSSScanInd->ieField,
11897 pReq->ieField,
11898 pReq->ieFieldLen);
11899
11900 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11901 if (WDI_STATUS_PENDING == status)
11902 {
11903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11904 "Pending received for %s:%d ",__func__,__LINE__ );
11905 }
11906 else if (WDI_STATUS_SUCCESS_SYNC != status)
11907 {
11908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11909 "Failure in %s:%d ",__func__,__LINE__ );
11910 }
11911 return CONVERT_WDI2VOS_STATUS(status) ;
11912}
11913/*
11914 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11915 *
11916 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11917 *
11918 * PARAM:
11919 * pWDA: pointer to WDA context
11920 * pReq: pointer to stop batch scan request
11921 */
11922VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11923 tANI_U8 *bssIdx)
11924{
11925 WDI_Status status;
11926
11927 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11928 "------> %s " ,__func__);
11929
11930 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11931 if (WDI_STATUS_PENDING == status)
11932 {
11933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11934 "Pending received for %s:%d ",__func__,__LINE__ );
11935 }
11936 else if (WDI_STATUS_SUCCESS_SYNC != status)
11937 {
11938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11939 "Failure in %s:%d ",__func__,__LINE__ );
11940 }
11941 return CONVERT_WDI2VOS_STATUS(status) ;
11942}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11943/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11944 * FUNCTION: WDA_ProcessRateUpdateInd
11945 *
11946 */
11947VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
11948 tSirRateUpdateInd *pRateUpdateParams)
11949{
11950 WDI_Status wdiStatus;
11951 WDI_RateUpdateIndParams rateUpdateParams;
11952
11953 vos_mem_copy(rateUpdateParams.bssid,
11954 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
11955
11956 rateUpdateParams.ucastDataRateTxFlag =
11957 pRateUpdateParams->ucastDataRateTxFlag;
11958 rateUpdateParams.reliableMcastDataRateTxFlag =
11959 pRateUpdateParams->reliableMcastDataRateTxFlag;
11960 rateUpdateParams.mcastDataRate24GHzTxFlag =
11961 pRateUpdateParams->mcastDataRate24GHzTxFlag;
11962 rateUpdateParams.mcastDataRate5GHzTxFlag =
11963 pRateUpdateParams->mcastDataRate5GHzTxFlag;
11964
11965 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
11966 rateUpdateParams.reliableMcastDataRate =
11967 pRateUpdateParams->reliableMcastDataRate;
11968 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
11969 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
11970
11971 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11972 rateUpdateParams.pUserData = pWDA;
11973
11974 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
11975
11976 if (WDI_STATUS_PENDING == wdiStatus)
11977 {
11978 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11979 "Pending received for %s:%d", __func__, __LINE__ );
11980 }
11981 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11982 {
11983 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11984 "Failure in %s:%d", __func__, __LINE__ );
11985 }
11986
11987 vos_mem_free(pRateUpdateParams);
11988
11989 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11990}
11991
11992/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11993 * -------------------------------------------------------------------------
11994 * DATA interface with WDI for Mgmt Frames
11995 * -------------------------------------------------------------------------
11996 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11997/*
11998 * FUNCTION: WDA_TxComplete
11999 * Callback function for the WDA_TxPacket
12000 */
12001VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
12002 VOS_STATUS status )
12003{
12004
12005 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12006 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12007 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12008
12009 if(NULL == wdaContext)
12010 {
12011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12012 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12013 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12014 VOS_ASSERT(0);
12015 return VOS_STATUS_E_FAILURE;
12016 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12017
12018 /*Check if frame was timed out or not*/
12019 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
12020 (v_PVOID_t)&uUserData);
12021
12022 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
12023 {
12024 /*Discard frame - no further processing is needed*/
12025 vos_pkt_return_packet(pData);
12026 return VOS_STATUS_SUCCESS;
12027 }
12028
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12029 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
12030 if( NULL!=wdaContext->pTxCbFunc)
12031 {
12032 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12033 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]12034 {
12035 wdaContext->pTxCbFunc(pMac, pData);
12036 }
12037 else
12038 {
12039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12040 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12041 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12042 //Return from here since we reaching here because the packet already timeout
12043 return status;
12044 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12045 }
12046
12047 /*
12048 * Trigger the event to bring the HAL TL Tx complete function to come
12049 * out of wait
12050 * Let the coe above to complete the packet first. When this event is set,
12051 * the thread waiting for the event may run and set Vospacket_freed causing the original
12052 * packet not being freed.
12053 */
12054 status = vos_event_set(&wdaContext->txFrameEvent);
12055 if(!VOS_IS_STATUS_SUCCESS(status))
12056 {
12057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12058 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12060 return status;
12061}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12062/*
12063 * FUNCTION: WDA_TxPacket
12064 * Forward TX management frame to WDI
12065 */
12066VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
12067 void *pFrmBuf,
12068 tANI_U16 frmLen,
12069 eFrameType frmType,
12070 eFrameTxDir txDir,
12071 tANI_U8 tid,
12072 pWDATxRxCompFunc pCompFunc,
12073 void *pData,
12074 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]12075 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12076{
12077 VOS_STATUS status = VOS_STATUS_SUCCESS ;
12078 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
12079 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
12080 tANI_U8 eventIdx = 0;
12081 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
12082 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12083 if((NULL == pWDA)||(NULL == pFrmBuf))
12084 {
12085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12086 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12087 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12088 VOS_ASSERT(0);
12089 return VOS_STATUS_E_FAILURE;
12090 }
12091
12092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12093 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12094 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
12095 if(NULL == pMac)
12096 {
12097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12098 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12099 VOS_ASSERT(0);
12100 return VOS_STATUS_E_FAILURE;
12101 }
12102
12103
12104
12105 /* store the call back function in WDA context */
12106 pWDA->pTxCbFunc = pCompFunc;
12107 /* store the call back for the function of ackTxComplete */
12108 if( pAckTxComp )
12109 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12110 if( NULL != pWDA->pAckTxCbFunc )
12111 {
12112 /* Already TxComp is active no need to active again */
12113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12114 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12115 pWDA->pAckTxCbFunc( pMac, 0);
12116 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12117
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12118 if( VOS_STATUS_SUCCESS !=
12119 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12120 {
12121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12122 "Tx Complete timeout Timer Stop Failed ");
12123 }
12124 else
12125 {
12126 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12127 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12128 }
12129 }
12130
12131 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
12132 pWDA->pAckTxCbFunc = pAckTxComp;
12133 if( VOS_STATUS_SUCCESS !=
12134 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
12135 {
12136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12137 "Tx Complete Timer Start Failed ");
12138 pWDA->pAckTxCbFunc = NULL;
12139 return eHAL_STATUS_FAILURE;
12140 }
12141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12142 /* Reset the event to be not signalled */
12143 status = vos_event_reset(&pWDA->txFrameEvent);
12144 if(!VOS_IS_STATUS_SUCCESS(status))
12145 {
12146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12147 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12148 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
12149 if( pAckTxComp )
12150 {
12151 pWDA->pAckTxCbFunc = NULL;
12152 if( VOS_STATUS_SUCCESS !=
12153 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12154 {
12155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12156 "Tx Complete timeout Timer Stop Failed ");
12157 }
12158 }
12159 return VOS_STATUS_E_FAILURE;
12160 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12161
12162 /* If Peer Sta mask is set don't overwrite to self sta */
12163 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12164 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12165 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12166 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12167 else
12168 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12169 /* Get system role, use the self station if in unknown role or STA role */
12170 systemRole = wdaGetGlobalSystemRole(pMac);
12171 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
12172 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12173#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12174 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12175#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12176 ))
12177 {
12178 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
12179 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]12180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12181
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12182 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
12183 disassoc frame reaches the HW, HAL has already deleted the peer station */
12184 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12185 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]12186 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12187 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12188 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12189 /*Send Probe request frames on self sta idx*/
12190 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12191 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12192 /* Since we donot want probe responses to be retried, send probe responses
12193 through the NO_ACK queues */
12194 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
12195 {
12196 //probe response is sent out using self station and no retries options.
12197 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
12198 }
12199 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
12200 {
12201 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
12202 }
12203 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12204 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]12205
12206 /*Set frame tag to 0
12207 We will use the WDA user data in order to tag a frame as expired*/
12208 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12209 (v_PVOID_t)0);
12210
12211
12212 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
12213 frmLen, ucTypeSubType, tid,
12214 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
12215 {
12216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12217 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12218 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12219 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]12220 if( pAckTxComp )
12221 {
12222 pWDA->pAckTxCbFunc = NULL;
12223 if( VOS_STATUS_SUCCESS !=
12224 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12225 {
12226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12227 "Tx Complete timeout Timer Stop Failed ");
12228 }
12229 }
12230 return VOS_STATUS_E_FAILURE;
12231 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12232 /*
12233 * Wait for the event to be set by the TL, to get the response of TX
12234 * complete, this event should be set by the Callback function called by TL
12235 */
12236 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12237 &eventIdx);
12238 if(!VOS_IS_STATUS_SUCCESS(status))
12239 {
12240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12241 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12242 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12243 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12244 after the packet gets completed(packet freed once)*/
12245
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12246 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame^]12247 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12248
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12249 /*Tag Frame as timed out for later deletion*/
12250 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12251 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12252
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12253 /* check whether the packet was freed already,so need not free again when
12254 * TL calls the WDA_Txcomplete routine
12255 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12256 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12257 /*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]12258 {
12259 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12260 } */
12261
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12262 if( pAckTxComp )
12263 {
12264 pWDA->pAckTxCbFunc = NULL;
12265 if( VOS_STATUS_SUCCESS !=
12266 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12267 {
12268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12269 "Tx Complete timeout Timer Stop Failed ");
12270 }
12271 }
12272 status = VOS_STATUS_E_FAILURE;
12273 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12274#ifdef WLAN_DUMP_MGMTFRAMES
12275 if (VOS_IS_STATUS_SUCCESS(status))
12276 {
12277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12278 "%s() TX packet : SubType %d", __func__,pFc->subType);
12279 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12280 pData, frmLen);
12281 }
12282#endif
12283
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12284 if (VOS_IS_STATUS_SUCCESS(status))
12285 {
12286 if (pMac->fEnableDebugLog & 0x1)
12287 {
12288 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12289 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12290 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12291 {
12292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12293 pFc->type, pFc->subType);
12294 }
12295 }
12296 }
12297
12298
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12299 return status;
12300}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12301/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12302 * FUNCTION: WDA_ProcessDHCPStartInd
12303 * Forward DHCP Start to WDI
12304 */
12305static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12306 tAniDHCPInd *dhcpStartInd)
12307{
12308 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12309 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12310
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12311 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12312 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12313 sizeof(tSirMacAddr));
12314
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12315 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12316
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12317 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12318 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12320 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12321 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12322 else if (WDI_STATUS_SUCCESS_SYNC != status)
12323 {
12324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12325 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12326 }
12327
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12328 vos_mem_free(dhcpStartInd);
12329 return CONVERT_WDI2VOS_STATUS(status) ;
12330}
12331
12332 /*
12333 * FUNCTION: WDA_ProcessDHCPStopInd
12334 * Forward DHCP Stop to WDI
12335 */
12336 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12337 tAniDHCPInd *dhcpStopInd)
12338 {
12339 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12340 WDI_DHCPInd wdiDHCPInd;
12341
12342 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12343 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12344
12345 status = WDI_dhcpStopInd(&wdiDHCPInd);
12346
12347 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12348 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12350 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12351 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12352 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12353 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12355 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12356 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12357
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12358 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12359
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12360 return CONVERT_WDI2VOS_STATUS(status) ;
12361 }
12362
12363/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12364 * FUNCTION: WDA_McProcessMsg
12365 * Trigger DAL-AL to start CFG download
12366 */
12367VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12368{
12369 VOS_STATUS status = VOS_STATUS_SUCCESS;
12370 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12371 if(NULL == pMsg)
12372 {
12373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12374 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12375 VOS_ASSERT(0);
12376 return VOS_STATUS_E_FAILURE;
12377 }
12378
12379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12380 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12381
12382 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12383 if(NULL == pWDA )
12384 {
12385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12386 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12387 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12388 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12389 return VOS_STATUS_E_FAILURE;
12390 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12391 /* Process all the WDA messages.. */
12392 switch( pMsg->type )
12393 {
12394 case WNI_CFG_DNLD_REQ:
12395 {
12396 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12397 /* call WDA complete event if config download success */
12398 if( VOS_IS_STATUS_SUCCESS(status) )
12399 {
12400 vos_WDAComplete_cback(pVosContext);
12401 }
12402 else
12403 {
12404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12405 "WDA Config Download failure" );
12406 }
12407 break ;
12408 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12409 /*
12410 * Init SCAN request from PE, convert it into DAL format
12411 * and send it to DAL
12412 */
12413 case WDA_INIT_SCAN_REQ:
12414 {
12415 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12416 break ;
12417 }
12418 /* start SCAN request from PE */
12419 case WDA_START_SCAN_REQ:
12420 {
12421 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12422 break ;
12423 }
12424 /* end SCAN request from PE */
12425 case WDA_END_SCAN_REQ:
12426 {
12427 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12428 break ;
12429 }
12430 /* end SCAN request from PE */
12431 case WDA_FINISH_SCAN_REQ:
12432 {
12433 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12434 break ;
12435 }
12436 /* join request from PE */
12437 case WDA_CHNL_SWITCH_REQ:
12438 {
12439 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12440 {
12441 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12442 }
12443 else
12444 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12445 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12446 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12447 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12448 {
12449 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12450 "call ProcessChannelSwitchReq_V1" );
12451 WDA_ProcessChannelSwitchReq_V1(pWDA,
12452 (tSwitchChannelParams*)pMsg->bodyptr) ;
12453 }
12454 else
12455 {
12456 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12457 "call ProcessChannelSwitchReq" );
12458 WDA_ProcessChannelSwitchReq(pWDA,
12459 (tSwitchChannelParams*)pMsg->bodyptr) ;
12460 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12461 }
12462 break ;
12463 }
12464 /* ADD BSS request from PE */
12465 case WDA_ADD_BSS_REQ:
12466 {
12467 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12468 break ;
12469 }
12470 case WDA_ADD_STA_REQ:
12471 {
12472 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12473 break ;
12474 }
12475 case WDA_DELETE_BSS_REQ:
12476 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12477 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12478 break ;
12479 }
12480 case WDA_DELETE_STA_REQ:
12481 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12482 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12483 break ;
12484 }
12485 case WDA_CONFIG_PARAM_UPDATE_REQ:
12486 {
12487 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12488 break ;
12489 }
12490 case WDA_SET_BSSKEY_REQ:
12491 {
12492 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12493 break ;
12494 }
12495 case WDA_SET_STAKEY_REQ:
12496 {
12497 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12498 break ;
12499 }
12500 case WDA_SET_STA_BCASTKEY_REQ:
12501 {
12502 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12503 break ;
12504 }
12505 case WDA_REMOVE_BSSKEY_REQ:
12506 {
12507 WDA_ProcessRemoveBssKeyReq(pWDA,
12508 (tRemoveBssKeyParams *)pMsg->bodyptr);
12509 break ;
12510 }
12511 case WDA_REMOVE_STAKEY_REQ:
12512 {
12513 WDA_ProcessRemoveStaKeyReq(pWDA,
12514 (tRemoveStaKeyParams *)pMsg->bodyptr);
12515 break ;
12516 }
12517 case WDA_REMOVE_STA_BCASTKEY_REQ:
12518 {
12519 /* TODO: currently UMAC is not sending this request, Add the code for
12520 handling this request when UMAC supports */
12521 break;
12522 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12523#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12524 case WDA_TSM_STATS_REQ:
12525 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12526 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12527 break;
12528 }
12529#endif
12530 case WDA_UPDATE_EDCA_PROFILE_IND:
12531 {
12532 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12533 break;
12534 }
12535 case WDA_ADD_TS_REQ:
12536 {
12537 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12538 break;
12539 }
12540 case WDA_DEL_TS_REQ:
12541 {
12542 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12543 break;
12544 }
12545 case WDA_ADDBA_REQ:
12546 {
12547 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12548 break;
12549 }
12550 case WDA_DELBA_IND:
12551 {
12552 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12553 break;
12554 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12555 case WDA_UPDATE_CHAN_LIST_REQ:
12556 {
12557 WDA_ProcessUpdateChannelList(pWDA,
12558 (tSirUpdateChanList *)pMsg->bodyptr);
12559 break;
12560 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12561 case WDA_SET_LINK_STATE:
12562 {
12563 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12564 break;
12565 }
12566 case WDA_GET_STATISTICS_REQ:
12567 {
12568 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12569 break;
12570 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12571#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12572 case WDA_GET_ROAM_RSSI_REQ:
12573 {
12574 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12575 break;
12576 }
12577#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12578 case WDA_PWR_SAVE_CFG:
12579 {
12580 if(pWDA->wdaState == WDA_READY_STATE)
12581 {
12582 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12583 }
12584 else
12585 {
12586 if(NULL != pMsg->bodyptr)
12587 {
12588 vos_mem_free(pMsg->bodyptr);
12589 }
12590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12591 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12592 }
12593 break;
12594 }
12595 case WDA_ENTER_IMPS_REQ:
12596 {
12597 if(pWDA->wdaState == WDA_READY_STATE)
12598 {
12599 WDA_ProcessEnterImpsReq(pWDA);
12600 }
12601 else
12602 {
12603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12604 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12605 }
12606 break;
12607 }
12608 case WDA_EXIT_IMPS_REQ:
12609 {
12610 if(pWDA->wdaState == WDA_READY_STATE)
12611 {
12612 WDA_ProcessExitImpsReq(pWDA);
12613 }
12614 else
12615 {
12616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12617 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12618 }
12619 break;
12620 }
12621 case WDA_ENTER_BMPS_REQ:
12622 {
12623 if(pWDA->wdaState == WDA_READY_STATE)
12624 {
12625 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12626 }
12627 else
12628 {
12629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12630 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12631 }
12632 break;
12633 }
12634 case WDA_EXIT_BMPS_REQ:
12635 {
12636 if(pWDA->wdaState == WDA_READY_STATE)
12637 {
12638 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12639 }
12640 else
12641 {
12642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12643 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12644 }
12645 break;
12646 }
12647 case WDA_ENTER_UAPSD_REQ:
12648 {
12649 if(pWDA->wdaState == WDA_READY_STATE)
12650 {
12651 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12652 }
12653 else
12654 {
12655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12656 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12657 }
12658 break;
12659 }
12660 case WDA_EXIT_UAPSD_REQ:
12661 {
12662 if(pWDA->wdaState == WDA_READY_STATE)
12663 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12664 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12665 }
12666 else
12667 {
12668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12669 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12670 }
12671 break;
12672 }
12673 case WDA_UPDATE_UAPSD_IND:
12674 {
12675 if(pWDA->wdaState == WDA_READY_STATE)
12676 {
12677 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12678 }
12679 else
12680 {
12681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12682 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12683 }
12684 break;
12685 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12686 case WDA_REGISTER_PE_CALLBACK :
12687 {
12688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12689 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12690 /*TODO: store the PE callback */
12691 /* Do Nothing? MSG Body should be freed at here */
12692 if(NULL != pMsg->bodyptr)
12693 {
12694 vos_mem_free(pMsg->bodyptr);
12695 }
12696 break;
12697 }
12698 case WDA_SYS_READY_IND :
12699 {
12700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12701 "Handling msg type WDA_SYS_READY_IND " );
12702 pWDA->wdaState = WDA_READY_STATE;
12703 if(NULL != pMsg->bodyptr)
12704 {
12705 vos_mem_free(pMsg->bodyptr);
12706 }
12707 break;
12708 }
12709 case WDA_BEACON_FILTER_IND :
12710 {
12711 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12712 break;
12713 }
12714 case WDA_BTC_SET_CFG:
12715 {
12716 /*TODO: handle this while dealing with BTC */
12717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12718 "Handling msg type WDA_BTC_SET_CFG " );
12719 /* Do Nothing? MSG Body should be freed at here */
12720 if(NULL != pMsg->bodyptr)
12721 {
12722 vos_mem_free(pMsg->bodyptr);
12723 }
12724 break;
12725 }
12726 case WDA_SIGNAL_BT_EVENT:
12727 {
12728 /*TODO: handle this while dealing with BTC */
12729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12730 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12731 /* Do Nothing? MSG Body should be freed at here */
12732 if(NULL != pMsg->bodyptr)
12733 {
12734 vos_mem_free(pMsg->bodyptr);
12735 }
12736 break;
12737 }
12738 case WDA_CFG_RXP_FILTER_REQ:
12739 {
12740 WDA_ProcessConfigureRxpFilterReq(pWDA,
12741 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12742 break;
12743 }
12744 case WDA_SET_HOST_OFFLOAD:
12745 {
12746 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12747 break;
12748 }
12749 case WDA_SET_KEEP_ALIVE:
12750 {
12751 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12752 break;
12753 }
12754#ifdef WLAN_NS_OFFLOAD
12755 case WDA_SET_NS_OFFLOAD:
12756 {
12757 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12758 break;
12759 }
12760#endif //WLAN_NS_OFFLOAD
12761 case WDA_ADD_STA_SELF_REQ:
12762 {
12763 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12764 break;
12765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12766 case WDA_DEL_STA_SELF_REQ:
12767 {
12768 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12769 break;
12770 }
12771 case WDA_WOWL_ADD_BCAST_PTRN:
12772 {
12773 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12774 break;
12775 }
12776 case WDA_WOWL_DEL_BCAST_PTRN:
12777 {
12778 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12779 break;
12780 }
12781 case WDA_WOWL_ENTER_REQ:
12782 {
12783 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12784 break;
12785 }
12786 case WDA_WOWL_EXIT_REQ:
12787 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12788 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12789 break;
12790 }
12791 case WDA_TL_FLUSH_AC_REQ:
12792 {
12793 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12794 break;
12795 }
12796 case WDA_SIGNAL_BTAMP_EVENT:
12797 {
12798 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12799 break;
12800 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12801#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12802 case WDA_LINK_LAYER_STATS_SET_REQ:
12803 {
12804 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12805 break;
12806 }
12807 case WDA_LINK_LAYER_STATS_GET_REQ:
12808 {
12809 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12810 break;
12811 }
12812 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12813 {
12814 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12815 break;
12816 }
12817#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12818#ifdef WLAN_FEATURE_EXTSCAN
12819 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12820 {
12821 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12822 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12823 break;
12824 }
12825 case WDA_EXTSCAN_START_REQ:
12826 {
12827 WDA_ProcessEXTScanStartReq(pWDA,
12828 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12829 break;
12830 }
12831 case WDA_EXTSCAN_STOP_REQ:
12832 {
12833 WDA_ProcessEXTScanStopReq(pWDA,
12834 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12835 break;
12836 }
12837 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12838 {
12839 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12840 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12841 break;
12842 }
12843 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12844 {
12845 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12846 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12847 break;
12848 }
12849 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12850 {
12851 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12852 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12853 break;
12854 }
12855 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12856 {
12857 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12858 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12859 break;
12860 }
12861 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12862 {
12863 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12864 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12865 break;
12866 }
12867#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12868#ifdef WDA_UT
12869 case WDA_WDI_EVENT_MSG:
12870 {
12871 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12872 break ;
12873 }
12874#endif
12875 case WDA_UPDATE_BEACON_IND:
12876 {
12877 WDA_ProcessUpdateBeaconParams(pWDA,
12878 (tUpdateBeaconParams *)pMsg->bodyptr);
12879 break;
12880 }
12881 case WDA_SEND_BEACON_REQ:
12882 {
12883 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12884 break;
12885 }
12886 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12887 {
12888 WDA_ProcessUpdateProbeRspTemplate(pWDA,
12889 (tSendProbeRespParams *)pMsg->bodyptr);
12890 break;
12891 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12892#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12893 case WDA_SET_MAX_TX_POWER_REQ:
12894 {
12895 WDA_ProcessSetMaxTxPowerReq(pWDA,
12896 (tMaxTxPowerParams *)pMsg->bodyptr);
12897 break;
12898 }
12899#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]12900 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
12901 {
12902 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
12903 pMsg->bodyptr);
12904 break;
12905 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]12906 case WDA_SET_TX_POWER_REQ:
12907 {
12908 WDA_ProcessSetTxPowerReq(pWDA,
12909 (tSirSetTxPowerReq *)pMsg->bodyptr);
12910 break;
12911 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12912 case WDA_SET_P2P_GO_NOA_REQ:
12913 {
12914 WDA_ProcessSetP2PGONOAReq(pWDA,
12915 (tP2pPsParams *)pMsg->bodyptr);
12916 break;
12917 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12918 /* timer related messages */
12919 case WDA_TIMER_BA_ACTIVITY_REQ:
12920 {
12921 WDA_BaCheckActivity(pWDA) ;
12922 break ;
12923 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]12924
12925 /* timer related messages */
12926 case WDA_TIMER_TRAFFIC_STATS_IND:
12927 {
12928 WDA_TimerTrafficStatsInd(pWDA);
12929 break;
12930 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12931#ifdef WLAN_FEATURE_VOWIFI_11R
12932 case WDA_AGGR_QOS_REQ:
12933 {
12934 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
12935 break;
12936 }
12937#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12938 case WDA_FTM_CMD_REQ:
12939 {
12940 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
12941 break ;
12942 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12943#ifdef FEATURE_OEM_DATA_SUPPORT
12944 case WDA_START_OEM_DATA_REQ:
12945 {
12946 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
12947 break;
12948 }
12949#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12950 /* Tx Complete Time out Indication */
12951 case WDA_TX_COMPLETE_TIMEOUT_IND:
12952 {
12953 WDA_ProcessTxCompleteTimeOutInd(pWDA);
12954 break;
12955 }
12956 case WDA_WLAN_SUSPEND_IND:
12957 {
12958 WDA_ProcessWlanSuspendInd(pWDA,
12959 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
12960 break;
12961 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12962 case WDA_WLAN_RESUME_REQ:
12963 {
12964 WDA_ProcessWlanResumeReq(pWDA,
12965 (tSirWlanResumeParam *)pMsg->bodyptr) ;
12966 break;
12967 }
12968
12969 case WDA_UPDATE_CF_IND:
12970 {
12971 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
12972 pMsg->bodyptr = NULL;
12973 break;
12974 }
12975#ifdef FEATURE_WLAN_SCAN_PNO
12976 case WDA_SET_PNO_REQ:
12977 {
12978 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
12979 break;
12980 }
12981 case WDA_UPDATE_SCAN_PARAMS_REQ:
12982 {
12983 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
12984 break;
12985 }
12986 case WDA_SET_RSSI_FILTER_REQ:
12987 {
12988 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
12989 break;
12990 }
12991#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12992#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12993 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12994 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12995 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12996 break;
12997 }
12998#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12999 case WDA_SET_TX_PER_TRACKING_REQ:
13000 {
13001 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
13002 break;
13003 }
13004
13005#ifdef WLAN_FEATURE_PACKET_FILTERING
13006 case WDA_8023_MULTICAST_LIST_REQ:
13007 {
13008 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
13009 break;
13010 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13011 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
13012 {
13013 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
13014 break;
13015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13016 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
13017 {
13018 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
13019 break;
13020 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13021 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
13022 {
13023 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
13024 break;
13025 }
13026#endif // WLAN_FEATURE_PACKET_FILTERING
13027
13028
13029 case WDA_TRANSMISSION_CONTROL_IND:
13030 {
13031 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
13032 break;
13033 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13034 case WDA_SET_POWER_PARAMS_REQ:
13035 {
13036 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
13037 break;
13038 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13039#ifdef WLAN_FEATURE_GTK_OFFLOAD
13040 case WDA_GTK_OFFLOAD_REQ:
13041 {
13042 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
13043 break;
13044 }
13045
13046 case WDA_GTK_OFFLOAD_GETINFO_REQ:
13047 {
13048 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
13049 break;
13050 }
13051#endif //WLAN_FEATURE_GTK_OFFLOAD
13052
13053 case WDA_SET_TM_LEVEL_REQ:
13054 {
13055 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
13056 break;
13057 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13058
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13059 case WDA_UPDATE_OP_MODE:
13060 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13061 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
13062 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
13063 {
13064 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13065 }
13066 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13067 {
13068 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
13069 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13070 else
13071 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13072 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13073 }
13074 else
13075 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13076 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13077 break;
13078 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]13079#ifdef WLAN_FEATURE_11W
13080 case WDA_EXCLUDE_UNENCRYPTED_IND:
13081 {
13082 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
13083 break;
13084 }
13085#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13086#ifdef FEATURE_WLAN_TDLS
13087 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
13088 {
13089 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
13090 break;
13091 }
13092#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13093 case WDA_DHCP_START_IND:
13094 {
13095 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13096 break;
13097 }
13098 case WDA_DHCP_STOP_IND:
13099 {
13100 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13101 break;
13102 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13103#ifdef FEATURE_WLAN_LPHB
13104 case WDA_LPHB_CONF_REQ:
13105 {
13106 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
13107 break;
13108 }
13109#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13110 case WDA_ADD_PERIODIC_TX_PTRN_IND:
13111 {
13112 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
13113 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
13114 break;
13115 }
13116 case WDA_DEL_PERIODIC_TX_PTRN_IND:
13117 {
13118 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
13119 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
13120 break;
13121 }
13122
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13123#ifdef FEATURE_WLAN_BATCH_SCAN
13124 case WDA_SET_BATCH_SCAN_REQ:
13125 {
13126 WDA_ProcessSetBatchScanReq(pWDA,
13127 (tSirSetBatchScanReq *)pMsg->bodyptr);
13128 break;
13129 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13130 case WDA_RATE_UPDATE_IND:
13131 {
13132 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
13133 break;
13134 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13135 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
13136 {
13137 WDA_ProcessTriggerBatchScanResultInd(pWDA,
13138 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
13139 break;
13140 }
13141 case WDA_STOP_BATCH_SCAN_IND:
13142 {
13143 WDA_ProcessStopBatchScanInd(pWDA,
13144 (tSirStopBatchScanInd *)pMsg->bodyptr);
13145 break;
13146 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]13147 case WDA_GET_BCN_MISS_RATE_REQ:
13148 WDA_ProcessGetBcnMissRateReq(pWDA,
13149 (tSirBcnMissRateReq *)pMsg->bodyptr);
13150 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13151#endif
13152
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13153 case WDA_HT40_OBSS_SCAN_IND:
13154 {
13155 WDA_ProcessHT40OBSSScanInd(pWDA,
13156 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
13157 break;
13158 }
13159 case WDA_HT40_OBSS_STOP_SCAN_IND:
13160 {
13161 WDA_ProcessHT40OBSSStopScanInd(pWDA,
13162 (tANI_U8*)pMsg->bodyptr);
13163 break;
13164 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]13165// tdlsoffchan
13166#ifdef FEATURE_WLAN_TDLS
13167 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
13168 {
13169 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
13170 break;
13171 }
13172#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13173 default:
13174 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]13175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13176 "No Handling for msg type %x in WDA "
13177 ,pMsg->type);
13178 /* Do Nothing? MSG Body should be freed at here */
13179 if(NULL != pMsg->bodyptr)
13180 {
13181 vos_mem_free(pMsg->bodyptr);
13182 }
13183 //WDA_VOS_ASSERT(0) ;
13184 }
13185 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13186 return status ;
13187}
13188
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13189/*
13190 * FUNCTION: WDA_LowLevelIndCallback
13191 * IND API callback from WDI, send Ind to PE
13192 */
13193void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
13194 void* pUserData )
13195{
13196 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
13197#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13198 tSirRSSINotification rssiNotification;
13199#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13200 if(NULL == pWDA)
13201 {
13202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13203 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13204 VOS_ASSERT(0);
13205 return ;
13206 }
13207
13208 switch(wdiLowLevelInd->wdiIndicationType)
13209 {
13210 case WDI_RSSI_NOTIFICATION_IND:
13211 {
13212 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13213 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13214#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13215 rssiNotification.bReserved =
13216 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
13217 rssiNotification.bRssiThres1NegCross =
13218 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
13219 rssiNotification.bRssiThres1PosCross =
13220 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
13221 rssiNotification.bRssiThres2NegCross =
13222 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
13223 rssiNotification.bRssiThres2PosCross =
13224 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
13225 rssiNotification.bRssiThres3NegCross =
13226 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
13227 rssiNotification.bRssiThres3PosCross =
13228 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]13229 rssiNotification.avgRssi = (v_S7_t)
13230 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13231 WLANTL_BMPSRSSIRegionChangedNotification(
13232 pWDA->pVosContext,
13233 &rssiNotification);
13234#endif
13235 break ;
13236 }
13237 case WDI_MISSED_BEACON_IND:
13238 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13239 tpSirSmeMissedBeaconInd pMissBeacInd =
13240 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13242 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13243 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13244 if(NULL == pMissBeacInd)
13245 {
13246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13247 "%s: VOS MEM Alloc Failure", __func__);
13248 break;
13249 }
13250 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13251 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13252 pMissBeacInd->bssIdx =
13253 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13254 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13255 break ;
13256 }
13257 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13258 {
13259 /* TODO: Decode Ind and send Ind to PE */
13260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13261 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13262 break ;
13263 }
13264
13265 case WDI_MIC_FAILURE_IND:
13266 {
13267 tpSirSmeMicFailureInd pMicInd =
13268 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13269
13270 if(NULL == pMicInd)
13271 {
13272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13273 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13274 break;
13275 }
13276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13277 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13278 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13279 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13280 vos_mem_copy(pMicInd->bssId,
13281 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13282 sizeof(tSirMacAddr));
13283 vos_mem_copy(pMicInd->info.srcMacAddr,
13284 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13285 sizeof(tSirMacAddr));
13286 vos_mem_copy(pMicInd->info.taMacAddr,
13287 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13288 sizeof(tSirMacAddr));
13289 vos_mem_copy(pMicInd->info.dstMacAddr,
13290 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13291 sizeof(tSirMacAddr));
13292 vos_mem_copy(pMicInd->info.rxMacAddr,
13293 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13294 sizeof(tSirMacAddr));
13295 pMicInd->info.multicast =
13296 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13297 pMicInd->info.keyId=
13298 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13299 pMicInd->info.IV1=
13300 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13301 vos_mem_copy(pMicInd->info.TSC,
13302 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13303 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13304 (void *)pMicInd , 0) ;
13305 break ;
13306 }
13307 case WDI_FATAL_ERROR_IND:
13308 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13309 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13310 /* TODO: Decode Ind and send Ind to PE */
13311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13312 "Received WDI_FATAL_ERROR_IND from WDI ");
13313 break ;
13314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13315 case WDI_DEL_STA_IND:
13316 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13317 tpDeleteStaContext pDelSTACtx =
13318 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13319
13320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13321 "Received WDI_DEL_STA_IND from WDI ");
13322 if(NULL == pDelSTACtx)
13323 {
13324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13325 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13326 break;
13327 }
13328 vos_mem_copy(pDelSTACtx->addr2,
13329 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13330 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13331 vos_mem_copy(pDelSTACtx->bssId,
13332 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13333 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13334 pDelSTACtx->assocId =
13335 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13336 pDelSTACtx->reasonCode =
13337 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13338 pDelSTACtx->staId =
13339 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13340 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13341 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13342 break ;
13343 }
13344 case WDI_COEX_IND:
13345 {
13346 tANI_U32 index;
13347 vos_msg_t vosMsg;
13348 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13349 if(NULL == pSmeCoexInd)
13350 {
13351 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13352 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13353 break;
13354 }
13355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13356 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13357 /* Message Header */
13358 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13359 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13360 /* Info from WDI Indication */
13361 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13362 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13363 {
13364 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13366 /* VOS message wrapper */
13367 vosMsg.type = eWNI_SME_COEX_IND;
13368 vosMsg.bodyptr = (void *)pSmeCoexInd;
13369 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13370 /* Send message to SME */
13371 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13372 {
13373 /* free the mem and return */
13374 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13375 }
13376 else
13377 {
13378 /* DEBUG */
13379 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13380 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13381 pSmeCoexInd->coexIndType,
13382 pSmeCoexInd->coexIndData[0],
13383 pSmeCoexInd->coexIndData[1],
13384 pSmeCoexInd->coexIndData[2],
13385 pSmeCoexInd->coexIndData[3]);
13386 }
13387 break;
13388 }
13389 case WDI_TX_COMPLETE_IND:
13390 {
13391 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13392 /* Calling TxCompleteAck Indication from wda context*/
13393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13394 "Complete Indication received from HAL");
13395 if( pWDA->pAckTxCbFunc )
13396 {
13397 if( VOS_STATUS_SUCCESS !=
13398 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13399 {
13400 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13401 "Tx Complete timeout Timer Stop Failed ");
13402 }
13403 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13404 pWDA->pAckTxCbFunc = NULL;
13405 }
13406 else
13407 {
13408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13409 "Tx Complete Indication is received after timeout ");
13410 }
13411 break;
13412 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13413 case WDI_P2P_NOA_START_IND :
13414 {
13415 tSirP2PNoaStart *pP2pNoaStart =
13416 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13417
13418 if (NULL == pP2pNoaStart)
13419 {
13420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13421 "Memory allocation failure, "
13422 "WDI_P2P_NOA_START_IND not forwarded");
13423 break;
13424 }
13425 pP2pNoaStart->status =
13426 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13427 pP2pNoaStart->bssIdx =
13428 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13429 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13430 (void *)pP2pNoaStart , 0) ;
13431 break;
13432 }
13433
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13434#ifdef FEATURE_WLAN_TDLS
13435 case WDI_TDLS_IND :
13436 {
13437 tSirTdlsInd *pTdlsInd =
13438 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13439
13440 if (NULL == pTdlsInd)
13441 {
13442 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13443 "Memory allocation failure, "
13444 "WDI_TDLS_IND not forwarded");
13445 break;
13446 }
13447 pTdlsInd->status =
13448 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13449 pTdlsInd->assocId =
13450 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13451 pTdlsInd->staIdx =
13452 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13453 pTdlsInd->reasonCode =
13454 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13455 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13456 (void *)pTdlsInd , 0) ;
13457 break;
13458 }
13459#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13460 case WDI_P2P_NOA_ATTR_IND :
13461 {
13462 tSirP2PNoaAttr *pP2pNoaAttr =
13463 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13465 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13466 if (NULL == pP2pNoaAttr)
13467 {
13468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13469 "Memory allocation failure, "
13470 "WDI_P2P_NOA_ATTR_IND not forwarded");
13471 break;
13472 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13473 pP2pNoaAttr->index =
13474 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13475 pP2pNoaAttr->oppPsFlag =
13476 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13477 pP2pNoaAttr->ctWin =
13478 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13479
13480 pP2pNoaAttr->uNoa1IntervalCnt =
13481 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13482 pP2pNoaAttr->uNoa1Duration =
13483 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13484 pP2pNoaAttr->uNoa1Interval =
13485 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13486 pP2pNoaAttr->uNoa1StartTime =
13487 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13488 pP2pNoaAttr->uNoa2IntervalCnt =
13489 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13490 pP2pNoaAttr->uNoa2Duration =
13491 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13492 pP2pNoaAttr->uNoa2Interval =
13493 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13494 pP2pNoaAttr->uNoa2StartTime =
13495 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13496 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13497 (void *)pP2pNoaAttr , 0) ;
13498 break;
13499 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13500#ifdef FEATURE_WLAN_SCAN_PNO
13501 case WDI_PREF_NETWORK_FOUND_IND:
13502 {
13503 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13504 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13505 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13506 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13507 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13510 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13511 if (NULL == pPrefNetworkFoundInd)
13512 {
13513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13514 "Memory allocation failure, "
13515 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13516 if (NULL !=
13517 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13518 {
13519 wpalMemoryFree(
13520 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13521 );
13522 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13523 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13524 break;
13525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13526 /* Message Header */
13527 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13528 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13529
13530 /* Info from WDI Indication */
13531 pPrefNetworkFoundInd->ssId.length =
13532 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13533 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13534 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13535 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13536 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13537 if (NULL !=
13538 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13539 {
13540 pPrefNetworkFoundInd->frameLength =
13541 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13542 vos_mem_copy( pPrefNetworkFoundInd->data,
13543 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13544 pPrefNetworkFoundInd->frameLength);
13545 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13546 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13547 }
13548 else
13549 {
13550 pPrefNetworkFoundInd->frameLength = 0;
13551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13552 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13553 /* VOS message wrapper */
13554 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13555 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13556 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13557 /* Send message to SME */
13558 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13559 {
13560 /* free the mem and return */
13561 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13562 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13563 break;
13564 }
13565#endif // FEATURE_WLAN_SCAN_PNO
13566
13567#ifdef WLAN_WAKEUP_EVENTS
13568 case WDI_WAKE_REASON_IND:
13569 {
13570 vos_msg_t vosMsg;
13571 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13572 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13573 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13574
13575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13576 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13577 wdiLowLevelInd->wdiIndicationType,
13578 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13579 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13580 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13581
13582 if (NULL == pWakeReasonInd)
13583 {
13584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13585 "Memory allocation failure, "
13586 "WDI_WAKE_REASON_IND not forwarded");
13587 break;
13588 }
13589
13590 vos_mem_zero(pWakeReasonInd, allocSize);
13591
13592 /* Message Header */
13593 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13594 pWakeReasonInd->mesgLen = allocSize;
13595
13596 /* Info from WDI Indication */
13597 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13598 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13599 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13600 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13601 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13602 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13603 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13604 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13605
13606 /* VOS message wrapper */
13607 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13608 vosMsg.bodyptr = (void *) pWakeReasonInd;
13609 vosMsg.bodyval = 0;
13610
13611 /* Send message to SME */
13612 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13613 {
13614 /* free the mem and return */
13615 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13616 }
13617
13618 break;
13619 }
13620#endif // WLAN_WAKEUP_EVENTS
13621
13622 case WDI_TX_PER_HIT_IND:
13623 {
13624 vos_msg_t vosMsg;
13625 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13626 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13627 /* VOS message wrapper */
13628 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13629 vosMsg.bodyptr = NULL;
13630 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13631 /* Send message to SME */
13632 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13633 {
13634 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13635 }
13636 break;
13637 }
13638
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13639#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13640 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13641 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13642 vos_msg_t vosMsg;
13643 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13644
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13645 lphbInd =
13646 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13647 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13648 {
13649 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13650 "%s: LPHB IND buffer alloc Fail", __func__);
13651 return ;
13652 }
13653
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13654 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13655 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13656 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13657 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13658 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13659 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13660
13661 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13662 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13663 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13664
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13665 vosMsg.type = eWNI_SME_LPHB_IND;
13666 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13667 vosMsg.bodyval = 0;
13668 /* Send message to SME */
13669 if (VOS_STATUS_SUCCESS !=
13670 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13671 {
13672 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13673 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13674 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13675 }
13676 break;
13677 }
13678#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13679 case WDI_PERIODIC_TX_PTRN_FW_IND:
13680 {
13681 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13682 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13683 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13684 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13685 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13686 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13687 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13688
13689 break;
13690 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13691
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13692 case WDI_IBSS_PEER_INACTIVITY_IND:
13693 {
13694 tSirIbssPeerInactivityInd *pIbssInd =
13695 (tSirIbssPeerInactivityInd *)
13696 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13697
13698 if (NULL == pIbssInd)
13699 {
13700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13701 "Memory allocation failure, "
13702 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13703 break;
13704 }
13705
13706 pIbssInd->bssIdx =
13707 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13708 pIbssInd->staIdx =
13709 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13710 vos_mem_copy(pIbssInd->peerAddr,
13711 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13712 sizeof(tSirMacAddr));
13713 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13714 break;
13715 }
13716
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13717#ifdef FEATURE_WLAN_BATCH_SCAN
13718 case WDI_BATCH_SCAN_RESULT_IND:
13719 {
13720 void *pBatchScanResult;
13721 void *pCallbackContext;
13722 tpAniSirGlobal pMac;
13723
13724 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13725 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13726
13727 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13728 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13729 {
13730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13731 "%s:pWDA is NULL", __func__);
13732 VOS_ASSERT(0);
13733 return;
13734 }
13735
13736 pBatchScanResult =
13737 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13738 if (NULL == pBatchScanResult)
13739 {
13740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13741 "%s:Batch scan result from FW is null can't invoke HDD callback",
13742 __func__);
13743 VOS_ASSERT(0);
13744 return;
13745 }
13746
13747 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13748 if (NULL == pMac)
13749 {
13750 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13751 "%s:pMac is NULL", __func__);
13752 VOS_ASSERT(0);
13753 return;
13754 }
13755
13756 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13757 /*call hdd callback with set batch scan response data*/
13758 if(pMac->pmc.batchScanResultCallback)
13759 {
13760 pMac->pmc.batchScanResultCallback(pCallbackContext,
13761 pBatchScanResult);
13762 }
13763 else
13764 {
13765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13766 "%s:HDD callback is null", __func__);
13767 VOS_ASSERT(0);
13768 }
13769 break;
13770 }
13771#endif
13772
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13773#ifdef FEATURE_WLAN_CH_AVOID
13774 case WDI_CH_AVOID_IND:
13775 {
13776 vos_msg_t vosMsg;
13777 tSirChAvoidIndType *chAvoidInd;
13778
13779 chAvoidInd =
13780 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13781 if (NULL == chAvoidInd)
13782 {
13783 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13784 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13785 return ;
13786 }
13787
13788 chAvoidInd->avoidRangeCount =
13789 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13790 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13791 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13792 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13793
13794 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13795 "%s : WDA CH avoid notification", __func__);
13796
13797 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13798 vosMsg.bodyptr = chAvoidInd;
13799 vosMsg.bodyval = 0;
13800 /* Send message to SME */
13801 if (VOS_STATUS_SUCCESS !=
13802 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13803 {
13804 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13805 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13806 vos_mem_free(chAvoidInd);
13807 }
13808 break;
13809 }
13810#endif /* FEATURE_WLAN_CH_AVOID */
13811
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13812#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13813 case WDI_LL_STATS_RESULTS_IND:
13814 {
13815 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13816 tpAniSirGlobal pMac;
13817
13818 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13819 "Received WDI_LL_STATS_RESULTS_IND from FW");
13820
13821 /*sanity check*/
13822 if (NULL == pWDA)
13823 {
13824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13825 "%s:pWDA is NULL", __func__);
13826 VOS_ASSERT(0);
13827 return;
13828 }
13829
13830 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13831 (void *)wdiLowLevelInd->
13832 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13833 if (NULL == pLinkLayerStatsInd)
13834 {
13835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13836 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13837 __func__);
13838 VOS_ASSERT(0);
13839 return;
13840 }
13841
13842 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13843 if (NULL == pMac)
13844 {
13845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13846 "%s:pMac is NULL", __func__);
13847 VOS_ASSERT(0);
13848 return;
13849 }
13850
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13851 /* call hdd callback with Link Layer Statistics.
13852 * vdev_id/ifacId in link_stats_results will be
13853 * used to retrieve the correct HDD context
13854 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13855 if (pMac->sme.pLinkLayerStatsIndCallback)
13856 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13857 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13858 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13859 pLinkLayerStatsInd,
13860 wdiLowLevelInd->
13861 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13862 }
13863 else
13864 {
13865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13866 "%s:HDD callback is null", __func__);
13867 }
13868 break;
13869 }
13870#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13871
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13872#ifdef WLAN_FEATURE_EXTSCAN
13873 case WDI_EXTSCAN_PROGRESS_IND:
13874 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13875 case WDI_EXTSCAN_SCAN_RESULT_IND:
13876 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13877 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13878 {
13879 void *pEXTScanData;
13880 void *pCallbackContext;
13881 tpAniSirGlobal pMac;
13882 tANI_U16 indType;
13883
13884 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13885 "Received WDI_EXTSCAN Indications from FW");
13886 /*sanity check*/
13887 if (NULL == pWDA)
13888 {
13889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13890 "%s:pWDA is NULL", __func__);
13891 VOS_ASSERT(0);
13892 return;
13893 }
13894 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
13895 {
13896 indType = WDA_EXTSCAN_PROGRESS_IND;
13897
13898 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13899 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
13900 }
13901 if (wdiLowLevelInd->wdiIndicationType ==
13902 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
13903 {
13904 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
13905
13906 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13907 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
13908 }
13909 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
13910 {
13911 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
13912
13913 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13914 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
13915 }
13916 if (wdiLowLevelInd->wdiIndicationType ==
13917 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
13918 {
13919 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
13920
13921 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13922 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
13923 }
13924 if (wdiLowLevelInd->wdiIndicationType ==
13925 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
13926 {
13927 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
13928
13929 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13930 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
13931 }
13932
13933 pEXTScanData =
13934 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
13935 if (NULL == pEXTScanData)
13936 {
13937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13938 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
13939 __func__);
13940 VOS_ASSERT(0);
13941 return;
13942 }
13943
13944 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13945 if (NULL == pMac)
13946 {
13947 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13948 "%s:pMac is NULL", __func__);
13949 VOS_ASSERT(0);
13950 return;
13951 }
13952
13953 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
13954
13955 if(pMac->sme.pEXTScanIndCb)
13956 {
13957 pMac->sme.pEXTScanIndCb(pCallbackContext,
13958 indType,
13959 pEXTScanData);
13960 }
13961 else
13962 {
13963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13964 "%s:HDD callback is null", __func__);
13965 }
13966 break;
13967 }
13968#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]13969 case WDI_DEL_BA_IND:
13970 {
13971 tpBADeleteParams pDelBAInd =
13972 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
13973
13974 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13975 "Received WDI_DEL_BA_IND from WDI ");
13976 if(NULL == pDelBAInd)
13977 {
13978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13979 "%s: VOS MEM Alloc Failure", __func__);
13980 break;
13981 }
13982 vos_mem_copy(pDelBAInd->peerMacAddr,
13983 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
13984 sizeof(tSirMacAddr));
13985 vos_mem_copy(pDelBAInd->bssId,
13986 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
13987 sizeof(tSirMacAddr));
13988 pDelBAInd->staIdx =
13989 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
13990 pDelBAInd->baTID =
13991 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
13992 pDelBAInd->baDirection =
13993 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
13994 pDelBAInd->reasonCode =
13995 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
13996
13997 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
13998 (void *)pDelBAInd , 0) ;
13999 break;
14000 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14001
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14002 default:
14003 {
14004 /* TODO error */
14005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14006 "Received UNKNOWN Indication from WDI ");
14007 }
14008 }
14009 return ;
14010}
14011
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14012/*
14013 * BA related processing in WDA.
14014 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14015void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
14016 void* pUserData)
14017{
14018 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14019 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14020 if(NULL == pWdaParams)
14021 {
14022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14023 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14024 VOS_ASSERT(0) ;
14025 return ;
14026 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14027 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14028 vos_mem_free(pWdaParams->wdaMsgParam) ;
14029 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14030 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14032 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14033 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
14034 {
14035 tANI_U8 i = 0 ;
14036 tBaActivityInd *baActivityInd = NULL ;
14037 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
14038 tANI_U8 allocSize = sizeof(tBaActivityInd)
14039 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
14040 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
14041 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14042 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14043 if(NULL == baActivityInd)
14044 {
14045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14047 VOS_ASSERT(0) ;
14048 return;
14049 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14050 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
14051 sizeof(tSirMacAddr)) ;
14052 baActivityInd->baCandidateCnt = baCandidateCount ;
14053
14054 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
14055 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
14056
14057 for(i = 0 ; i < baCandidateCount ; i++)
14058 {
14059 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14060 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
14061 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14062 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
14063 {
14064 baCandidate->baInfo[tid].fBaEnable =
14065 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
14066 baCandidate->baInfo[tid].startingSeqNum =
14067 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
14068 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]14069 wdiBaCandidate++ ;
14070 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14071 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14072 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
14073 }
14074 else
14075 {
14076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14077 "BA Trigger RSP with Failure received ");
14078 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14079 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14080}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14081
14082
14083/*
14084 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
14085 * during MCC
14086 */
14087void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
14088{
14089 wpt_uint32 enabled;
14090 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
14091 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
14092 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
14093
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14094 if (NULL == pMac )
14095 {
14096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14097 "%s: Invoked with invalid MAC context ", __func__ );
14098 VOS_ASSERT(0);
14099 return;
14100 }
14101
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14102 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14103 != eSIR_SUCCESS)
14104 {
14105 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14106 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14107 return;
14108 }
14109
14110 if(!enabled)
14111 {
14112 return;
14113 }
14114
14115 if(NULL == pWDA)
14116 {
14117 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14118 "%s:WDA context is NULL", __func__);
14119 VOS_ASSERT(0);
14120 return;
14121 }
14122
14123 if(activate)
14124 {
14125 if( VOS_STATUS_SUCCESS !=
14126 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14127 {
14128 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14129 "Traffic Stats Timer Start Failed ");
14130 return;
14131 }
14132 WDI_DS_ActivateTrafficStats();
14133 }
14134 else
14135 {
14136 WDI_DS_DeactivateTrafficStats();
14137 WDI_DS_ClearTrafficStats();
14138
14139 if( VOS_STATUS_SUCCESS !=
14140 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14141 {
14142 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14143 "Traffic Stats Timer Stop Failed ");
14144 return;
14145 }
14146 }
14147}
14148
14149/*
14150 * Traffic Stats Timer handler
14151 */
14152void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
14153{
14154 WDI_Status wdiStatus;
14155 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
14156 WDI_TrafficStatsIndType trafficStatsIndParams;
14157 wpt_uint32 length, enabled;
14158 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14159
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14160 if (NULL == pMac )
14161 {
14162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14163 "%s: Invoked with invalid MAC context ", __func__ );
14164 VOS_ASSERT(0);
14165 return;
14166 }
14167
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14168 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14169 != eSIR_SUCCESS)
14170 {
14171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14172 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14173 return;
14174 }
14175
14176 if(!enabled)
14177 {
14178 WDI_DS_DeactivateTrafficStats();
14179 return;
14180 }
14181
14182 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
14183
14184 if(pWdiTrafficStats != NULL)
14185 {
14186 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
14187 trafficStatsIndParams.length = length;
14188 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]14189 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14190 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
14191 trafficStatsIndParams.pUserData = pWDA;
14192
14193 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
14194
14195 if(WDI_STATUS_PENDING == wdiStatus)
14196 {
14197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14198 "Pending received for %s:%d ",__func__,__LINE__ );
14199 }
14200 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
14201 {
14202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14203 "Failure in %s:%d ",__func__,__LINE__ );
14204 }
14205
14206 WDI_DS_ClearTrafficStats();
14207 }
14208 else
14209 {
14210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14211 "pWdiTrafficStats is Null");
14212 }
14213
14214 if( VOS_STATUS_SUCCESS !=
14215 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14216 {
14217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14218 "Traffic Stats Timer Start Failed ");
14219 return;
14220 }
14221}
14222
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14223/*
14224 * BA Activity check timer handler
14225 */
14226void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
14227{
14228 tANI_U8 curSta = 0 ;
14229 tANI_U8 tid = 0 ;
14230 tANI_U8 size = 0 ;
14231 tANI_U8 baCandidateCount = 0 ;
14232 tANI_U8 newBaCandidate = 0 ;
14233 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
14234
14235 if(NULL == pWDA)
14236 {
14237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14238 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14239 VOS_ASSERT(0);
14240 return ;
14241 }
14242 if(WDA_MAX_STA < pWDA->wdaMaxSta)
14243 {
14244 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14245 "Inconsistent STA entries in WDA");
14246 VOS_ASSERT(0) ;
14247 }
14248 /* walk through all STA entries and find out TX packet count */
14249 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
14250 {
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14251#ifdef WLAN_SOFTAP_VSTA_FEATURE
14252 // We can only do BA on "hard" STAs.
14253 if (!(IS_HWSTA_IDX(curSta)))
14254 {
14255 continue;
14256 }
14257#endif //WLAN_SOFTAP_VSTA_FEATURE
14258 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
14259 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14260 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14261 tANI_U32 txPktCount = 0 ;
14262 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14263 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14264 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
14265 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14266 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14267 curSta, tid, &txPktCount)))
14268 {
14269#if 0
14270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14271 "************* %d:%d, %d ",curSta, txPktCount,
14272 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14273#endif
14274 if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14275 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14276 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14277 curSta, tid)))
14278 {
14279 /* get prepare for sending message to HAL */
14280 //baCandidate[baCandidateCount].staIdx = curSta ;
14281 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14282 newBaCandidate = WDA_ENABLE_BA ;
14283 }
14284 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14285 }
14286 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14287 /* fill the entry for all the sta with given TID's */
14288 if(WDA_ENABLE_BA == newBaCandidate)
14289 {
14290 /* move to next BA candidate */
14291 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14292 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14293 baCandidateCount++ ;
14294 newBaCandidate = WDA_DISABLE_BA ;
14295 }
14296 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14297 /* prepare and send message to hal */
14298 if( 0 < baCandidateCount)
14299 {
14300 WDI_Status status = WDI_STATUS_SUCCESS ;
14301 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14302 tWDA_ReqParams *pWdaParams =
14303 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14304 if(NULL == pWdaParams)
14305 {
14306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14307 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14308 VOS_ASSERT(0) ;
14309 return;
14310 }
14311 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14312 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14313 if(NULL == wdiTriggerBaReq)
14314 {
14315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14316 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14317 VOS_ASSERT(0) ;
14318 vos_mem_free(pWdaParams);
14319 return;
14320 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14321 do
14322 {
14323 WDI_TriggerBAReqinfoType *triggerBaInfo =
14324 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14325 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14326 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14327 * for each request */
14328 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14329 triggerBaInfo->ucBASessionID = 0;
14330 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14331 } while(0) ;
14332 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14334 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14335 pWdaParams->pWdaContext = pWDA;
14336 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14337 pWdaParams->wdaMsgParam = NULL;
14338 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14339 WDA_TriggerBaReqCallback, pWdaParams) ;
14340 if(IS_WDI_STATUS_FAILURE(status))
14341 {
14342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14343 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14344 vos_mem_free(pWdaParams->wdaMsgParam) ;
14345 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14346 vos_mem_free(pWdaParams) ;
14347 }
14348 }
14349 else
14350 {
14351 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14352 "There is no TID for initiating BA");
14353 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14354 if( VOS_STATUS_SUCCESS !=
14355 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14356 {
14357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14358 "BA Activity Timer Stop Failed ");
14359 return ;
14360 }
14361 if( VOS_STATUS_SUCCESS !=
14362 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14363 {
14364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14365 "BA Activity Timer Start Failed ");
14366 return;
14367 }
14368 return ;
14369}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14370/*
14371 * WDA common routine to create timer used by WDA.
14372 */
14373static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14374{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14375 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14376 tANI_U32 val = 0 ;
14377 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14378
14379 if(NULL == pMac)
14380 {
14381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14382 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14383 VOS_ASSERT(0);
14384 return VOS_STATUS_E_FAILURE;
14385 }
14386 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14387 != eSIR_SUCCESS)
14388 {
14389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14390 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14391 return VOS_STATUS_E_FAILURE;
14392 }
14393 val = SYS_MS_TO_TICKS(val) ;
14394
14395 /* BA activity check timer */
14396 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14397 "BA Activity Check timer", WDA_TimerHandler,
14398 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14399 if(status != TX_SUCCESS)
14400 {
14401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14402 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14403 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14404 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14405 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14406 /* Tx Complete Timeout timer */
14407 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14408 "Tx Complete Check timer", WDA_TimerHandler,
14409 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14410 if(status != TX_SUCCESS)
14411 {
14412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14413 "Unable to create Tx Complete Timeout timer");
14414 /* Destroy timer of BA activity check timer */
14415 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14416 if(status != TX_SUCCESS)
14417 {
14418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14419 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14420 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14421 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14422 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14423 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14424
14425 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14426
14427 /* Traffic Stats timer */
14428 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14429 "Traffic Stats timer", WDA_TimerHandler,
14430 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14431 if(status != TX_SUCCESS)
14432 {
14433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14434 "Unable to create traffic stats timer");
14435 /* Destroy timer of BA activity check timer */
14436 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14437 if(status != TX_SUCCESS)
14438 {
14439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14440 "Unable to Destroy BA activity timer");
14441 }
14442 /* Destroy timer of tx complete timer */
14443 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14444 if(status != TX_SUCCESS)
14445 {
14446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14447 "Unable to Tx complete timer");
14448 }
14449 return VOS_STATUS_E_FAILURE ;
14450 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14451 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14452}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14453/*
14454 * WDA common routine to destroy timer used by WDA.
14455 */
14456static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14457{
14458 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14459 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14460 if(status != TX_SUCCESS)
14461 {
14462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14463 "Unable to Destroy Tx Complete Timeout timer");
14464 return eSIR_FAILURE ;
14465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14466 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14467 if(status != TX_SUCCESS)
14468 {
14469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14470 "Unable to Destroy BA activity timer");
14471 return eSIR_FAILURE ;
14472 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14473 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14474 if(status != TX_SUCCESS)
14475 {
14476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14477 "Unable to Destroy traffic stats timer");
14478 return eSIR_FAILURE ;
14479 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14480 return eSIR_SUCCESS ;
14481}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14482/*
14483 * WDA timer handler.
14484 */
14485void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14486{
14487 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14488 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14489 /*
14490 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14491 */
14492 wdaMsg.type = timerInfo ;
14493 wdaMsg.bodyptr = NULL;
14494 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14495 /* post the message.. */
14496 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14497 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14498 {
14499 vosStatus = VOS_STATUS_E_BADMSG;
14500 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14501}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14502/*
14503 * WDA Tx Complete timeout Indication.
14504 */
14505void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14506{
14507 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14508 if( pWDA->pAckTxCbFunc )
14509 {
14510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14511 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14512 pWDA->pAckTxCbFunc( pMac, 0);
14513 pWDA->pAckTxCbFunc = NULL;
14514 }
14515 else
14516 {
14517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14518 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14519 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14520}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14521/*
14522 * WDA Set REG Domain to VOS NV
14523 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14524eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14525 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14526{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14527 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14528 {
14529 return eHAL_STATUS_INVALID_PARAMETER;
14530 }
14531 return eHAL_STATUS_SUCCESS;
14532}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14534#ifdef FEATURE_WLAN_SCAN_PNO
14535/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14536 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14537 *
14538 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14539void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14540{
14541 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14542 tSirPNOScanReq *pPNOScanReqParams;
14543
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14544 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14545 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14546 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14547 {
14548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14549 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14550 VOS_ASSERT(0) ;
14551 return ;
14552 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14553
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14554 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14555 if(pPNOScanReqParams->statusCallback)
14556 {
14557 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14558 (status == WDI_STATUS_SUCCESS) ?
14559 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14560 }
14561
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14562 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14563 vos_mem_free(pWdaParams->wdaMsgParam);
14564 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14565
14566 return ;
14567}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14568/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14569 * FUNCTION: WDA_PNOScanReqCallback
14570 * Free memory.
14571 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14572 */
14573void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14574{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14575 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14576 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14577
14578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14579 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14580
14581 if(NULL == pWdaParams)
14582 {
14583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14584 "%s: pWdaParams received NULL", __func__);
14585 VOS_ASSERT(0);
14586 return;
14587 }
14588
14589 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14590 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14591 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14592 if(pPNOScanReqParams->statusCallback)
14593 {
14594 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14595 VOS_STATUS_E_FAILURE);
14596 }
14597
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14598 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14599 vos_mem_free(pWdaParams->wdaMsgParam);
14600 vos_mem_free(pWdaParams);
14601 }
14602
14603 return;
14604}
14605/*
14606 * FUNCTION: WDA_UpdateScanParamsRespCallback
14607 *
14608 */
14609void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14610{
14611 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14612 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14613 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14614 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14615 {
14616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14617 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14618 VOS_ASSERT(0) ;
14619 return ;
14620 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14621
14622 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14623 vos_mem_free(pWdaParams->wdaMsgParam);
14624 vos_mem_free(pWdaParams);
14625
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14626 return ;
14627}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14628/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14629 * FUNCTION: WDA_UpdateScanParamsReqCallback
14630 * Free memory.
14631 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14632 */
14633void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14634{
14635 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14636
14637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14638 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14639
14640 if(NULL == pWdaParams)
14641 {
14642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14643 "%s: pWdaParams received NULL", __func__);
14644 VOS_ASSERT(0);
14645 return;
14646 }
14647
14648 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14649 {
14650 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14651 vos_mem_free(pWdaParams->wdaMsgParam);
14652 vos_mem_free(pWdaParams);
14653 }
14654
14655 return;
14656}
14657/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14658 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14659 * Request to WDI to set Preferred Network List.Offload
14660 */
14661VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14662 tSirPNOScanReq *pPNOScanReqParams)
14663{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14664 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14665 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14666 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14667 tWDA_ReqParams *pWdaParams ;
14668 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14670 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14671 if(NULL == pwdiPNOScanReqInfo)
14672 {
14673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14674 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14675 VOS_ASSERT(0);
14676 return VOS_STATUS_E_NOMEM;
14677 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14678 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14679 if(NULL == pWdaParams)
14680 {
14681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14682 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14683 VOS_ASSERT(0);
14684 vos_mem_free(pwdiPNOScanReqInfo);
14685 return VOS_STATUS_E_NOMEM;
14686 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14687 //
14688 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14689 //
14690 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14691 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14692 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14693 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14694 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14695 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14696 {
14697 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14698 &pPNOScanReqParams->aNetworks[i],
14699 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14701 /*Scan timer intervals*/
14702 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14703 &pPNOScanReqParams->scanTimers,
14704 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14705 /*Probe template for 2.4GHz band*/
14706 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14707 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14708 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14709 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14710 pPNOScanReqParams->p24GProbeTemplate,
14711 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14712 /*Probe template for 5GHz band*/
14713 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14714 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14715 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14716 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14717 pPNOScanReqParams->p5GProbeTemplate,
14718 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14719 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14720 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14721
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14722 /* Store Params pass it to WDI */
14723 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14724 pWdaParams->pWdaContext = pWDA;
14725 /* Store param pointer as passed in by caller */
14726 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14727 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14728 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14729 if(IS_WDI_STATUS_FAILURE(status))
14730 {
14731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14732 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14733 if(pPNOScanReqParams->statusCallback)
14734 {
14735 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14736 VOS_STATUS_E_FAILURE);
14737 }
14738
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14740 vos_mem_free(pWdaParams->wdaMsgParam);
14741 pWdaParams->wdaWdiApiMsgParam = NULL;
14742 pWdaParams->wdaMsgParam = NULL;
14743 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14744 return CONVERT_WDI2VOS_STATUS(status) ;
14745}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14746
14747#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14748
14749void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14750{
14751 /*Convert the CSR Auth types to WDI Auth types */
14752 switch (csrAuthType)
14753 {
14754 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14755 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14756 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14757#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14758 case eCSR_AUTH_TYPE_CCKM_WPA:
14759 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14760 break;
14761#endif
14762 case eCSR_AUTH_TYPE_WPA:
14763 *AuthType = eWDA_AUTH_TYPE_WPA;
14764 break;
14765 case eCSR_AUTH_TYPE_WPA_PSK:
14766 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14767 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14768#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14769 case eCSR_AUTH_TYPE_CCKM_RSN:
14770 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14771 break;
14772#endif
14773 case eCSR_AUTH_TYPE_RSN:
14774 *AuthType = eWDA_AUTH_TYPE_RSN;
14775 break;
14776 case eCSR_AUTH_TYPE_RSN_PSK:
14777 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14778 break;
14779#if defined WLAN_FEATURE_VOWIFI_11R
14780 case eCSR_AUTH_TYPE_FT_RSN:
14781 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14782 break;
14783 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14784 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14785 break;
14786#endif
14787#ifdef FEATURE_WLAN_WAPI
14788 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14789 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14790 break;
14791 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14792 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14793 break;
14794#endif /* FEATURE_WLAN_WAPI */
14795 case eCSR_AUTH_TYPE_SHARED_KEY:
14796 case eCSR_AUTH_TYPE_AUTOSWITCH:
14797 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14798 break;
14799#if 0
14800 case eCSR_AUTH_TYPE_SHARED_KEY:
14801 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14802 break;
14803 case eCSR_AUTH_TYPE_AUTOSWITCH:
14804 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14805#endif
14806 default:
14807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14808 "%s: Unknown Auth Type", __func__);
14809 break;
14810 }
14811}
14812void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14813{
14814 switch (csrEncrType)
14815 {
14816 case eCSR_ENCRYPT_TYPE_NONE:
14817 *EncrType = WDI_ED_NONE;
14818 break;
14819 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14820 case eCSR_ENCRYPT_TYPE_WEP40:
14821 *EncrType = WDI_ED_WEP40;
14822 break;
14823 case eCSR_ENCRYPT_TYPE_WEP104:
14824 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14825 *EncrType = WDI_ED_WEP104;
14826 break;
14827 case eCSR_ENCRYPT_TYPE_TKIP:
14828 *EncrType = WDI_ED_TKIP;
14829 break;
14830 case eCSR_ENCRYPT_TYPE_AES:
14831 *EncrType = WDI_ED_CCMP;
14832 break;
14833#ifdef WLAN_FEATURE_11W
14834 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14835 *EncrType = WDI_ED_AES_128_CMAC;
14836 break;
14837#endif
14838#ifdef FEATURE_WLAN_WAPI
14839 case eCSR_ENCRYPT_TYPE_WPI:
14840 *EncrType = WDI_ED_WPI;
14841 break;
14842#endif
14843 case eCSR_ENCRYPT_TYPE_ANY:
14844 *EncrType = WDI_ED_ANY;
14845 break;
14846
14847 default:
14848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14849 "%s: Unknown Encryption Type", __func__);
14850 break;
14851 }
14852}
14853
14854/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14855 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14856 * Request to WDI to set Roam Offload Scan
14857 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14858VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14859 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
14860{
14861 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14862 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
14863 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14864 tWDA_ReqParams *pWdaParams ;
14865 v_U8_t csrAuthType;
14866 WDI_RoamNetworkType *pwdiRoamNetworkType;
14867 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
14868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14869 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14870 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14871 {
14872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14873 "%s: VOS MEM Alloc Failure", __func__);
14874 VOS_ASSERT(0);
14875 return VOS_STATUS_E_NOMEM;
14876 }
14877 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14878 if (NULL == pWdaParams)
14879 {
14880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14881 "%s: VOS MEM Alloc Failure", __func__);
14882 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14883 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14884 return VOS_STATUS_E_NOMEM;
14885 }
14886
14887 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14888 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14889 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14890 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
14891 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14892 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
14893 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
14894 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
14895 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
14896 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
14897 sizeof(pwdiRoamNetworkType->currAPbssid));
14898 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
14899 csrAuthType);
14900 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
14901 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
14902 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
14903 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
14904 pwdiRoamOffloadScanInfo->LookupThreshold =
14905 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]14906 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
14907 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14908 pwdiRoamOffloadScanInfo->RoamRssiDiff =
14909 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]14910 pwdiRoamOffloadScanInfo->MAWCEnabled =
14911 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14912 pwdiRoamOffloadScanInfo->Command =
14913 pRoamOffloadScanReqParams->Command ;
14914 pwdiRoamOffloadScanInfo->StartScanReason =
14915 pRoamOffloadScanReqParams->StartScanReason ;
14916 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
14917 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
14918 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
14919 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
14920 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
14921 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
14922 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
14923 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
14924 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
14925 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14926 pwdiRoamOffloadScanInfo->IsESEEnabled =
14927 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14928 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
14929 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
14930 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
14931 pwdiRoamNetworkType->ssId.ucLength =
14932 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
14933 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
14934 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
14935 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
14936 pwdiRoamNetworkType->ChannelCount =
14937 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
14938 pwdiRoamOffloadScanInfo->ChannelCacheType =
14939 pRoamOffloadScanReqParams->ChannelCacheType;
14940 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
14941 pRoamOffloadScanReqParams->ValidChannelList,
14942 pRoamOffloadScanReqParams->ValidChannelCount);
14943 pwdiRoamOffloadScanInfo->ValidChannelCount =
14944 pRoamOffloadScanReqParams->ValidChannelCount;
14945 pwdiRoamOffloadScanInfo->us24GProbeSize =
14946 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14947 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14948 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
14949 pRoamOffloadScanReqParams->p24GProbeTemplate,
14950 pwdiRoamOffloadScanInfo->us24GProbeSize);
14951 pwdiRoamOffloadScanInfo->us5GProbeSize =
14952 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14953 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14954 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
14955 pRoamOffloadScanReqParams->p5GProbeTemplate,
14956 pwdiRoamOffloadScanInfo->us5GProbeSize);
14957 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
14958 pRoamOffloadScanReqParams->MDID.mdiePresent;
14959 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
14960 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14961 pwdiRoamOffloadScanInfo->nProbes =
14962 pRoamOffloadScanReqParams->nProbes;
14963 pwdiRoamOffloadScanInfo->HomeAwayTime =
14964 pRoamOffloadScanReqParams->HomeAwayTime;
14965 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14966 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14967 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14968 pWdaParams->pWdaContext = pWDA;
14969 /* Store param pointer as passed in by caller */
14970 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14971 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14972 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
14973 if(IS_WDI_STATUS_FAILURE(status))
14974 {
14975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14976 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
14977 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14978 vos_mem_free(pWdaParams->wdaMsgParam);
14979 pWdaParams->wdaWdiApiMsgParam = NULL;
14980 pWdaParams->wdaMsgParam = NULL;
14981 }
14982 return CONVERT_WDI2VOS_STATUS(status) ;
14983}
14984#endif
14985
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14986/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14987 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14988 *
14989 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14990void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14991{
14992 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14993
14994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14995 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14996
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14997 if(NULL == pWdaParams)
14998 {
14999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15000 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15001 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15002 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15003 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15004
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15005 vos_mem_free(pWdaParams->wdaMsgParam) ;
15006 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15007 vos_mem_free(pWdaParams) ;
15008
15009 return ;
15010}
15011/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15012 * FUNCTION: WDA_RssiFilterReqCallback
15013 * Free memory.
15014 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
15015 */
15016void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15017{
15018 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15019
15020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15021 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15022
15023 if(NULL == pWdaParams)
15024 {
15025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15026 "%s: pWdaParams received NULL", __func__);
15027 VOS_ASSERT(0);
15028 return;
15029 }
15030
15031 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15032 {
15033 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15034 vos_mem_free(pWdaParams->wdaMsgParam);
15035 vos_mem_free(pWdaParams);
15036 }
15037
15038 return;
15039}
15040/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15041 * FUNCTION: WDA_ProcessSetPreferredNetworkList
15042 * Request to WDI to set Preferred Network List.Offload
15043 */
15044VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
15045 tSirSetRSSIFilterReq* pRssiFilterParams)
15046{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15047 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15048 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
15049 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
15050 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15052 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15053 if(NULL == pwdiSetRssiFilterReqInfo)
15054 {
15055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15056 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15057 VOS_ASSERT(0);
15058 return VOS_STATUS_E_NOMEM;
15059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15060 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15061 if(NULL == pWdaParams)
15062 {
15063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15064 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15065 VOS_ASSERT(0);
15066 vos_mem_free(pwdiSetRssiFilterReqInfo);
15067 return VOS_STATUS_E_NOMEM;
15068 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15069 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15070 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
15071 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15072
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15073 /* Store Params pass it to WDI */
15074 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
15075 pWdaParams->pWdaContext = pWDA;
15076 /* Store param pointer as passed in by caller */
15077 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15078 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15079 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15080 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15081 if(IS_WDI_STATUS_FAILURE(status))
15082 {
15083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15084 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
15085 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15086 vos_mem_free(pWdaParams->wdaMsgParam);
15087 pWdaParams->wdaWdiApiMsgParam = NULL;
15088 pWdaParams->wdaMsgParam = NULL;
15089 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15090 return CONVERT_WDI2VOS_STATUS(status) ;
15091}
15092
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15093/*
15094 * FUNCTION: WDA_ProcessUpdateScanParams
15095 * Request to WDI to update Scan Parameters
15096 */
15097VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
15098 tSirUpdateScanParams *pUpdateScanParams)
15099{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15100 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15101 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
15102 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
15103 sizeof(WDI_UpdateScanParamsInfoType)) ;
15104 tWDA_ReqParams *pWdaParams ;
15105 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15107 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15108 if(NULL == wdiUpdateScanParamsInfoType)
15109 {
15110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15111 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15112 VOS_ASSERT(0);
15113 return VOS_STATUS_E_NOMEM;
15114 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15115 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15116 if ( NULL == pWdaParams )
15117 {
15118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15119 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15120 VOS_ASSERT(0);
15121 vos_mem_free(wdiUpdateScanParamsInfoType);
15122 return VOS_STATUS_E_NOMEM;
15123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15124 //
15125 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
15126 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15128 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
15129 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
15130 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]15131 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15132 pUpdateScanParams->b11dEnabled,
15133 pUpdateScanParams->b11dResolved,
15134 pUpdateScanParams->ucChannelCount,
15135 pUpdateScanParams->usPassiveMinChTime,
15136 pUpdateScanParams->usPassiveMaxChTime,
15137 pUpdateScanParams->usActiveMinChTime,
15138 pUpdateScanParams->usActiveMaxChTime,
15139 sizeof(tSirUpdateScanParams),
15140 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
15141
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15142 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
15143 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15144 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
15145 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15146 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
15147 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15148 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
15149 pUpdateScanParams->usActiveMaxChTime;
15150 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
15151 pUpdateScanParams->usActiveMinChTime;
15152 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
15153 pUpdateScanParams->usPassiveMaxChTime;
15154 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
15155 pUpdateScanParams->usPassiveMinChTime;
15156
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15157 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]15158 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
15159 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15160
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15161 for ( i = 0; i <
15162 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
15163 i++)
15164 {
15165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15166 "Update Scan Parameters channel: %d",
15167 pUpdateScanParams->aChannels[i]);
15168
15169 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
15170 pUpdateScanParams->aChannels[i];
15171 }
15172
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15173 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
15174 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15175
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15176 /* Store Params pass it to WDI */
15177 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
15178 pWdaParams->pWdaContext = pWDA;
15179 /* Store param pointer as passed in by caller */
15180 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15181
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15182
15183
15184 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15185 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15186 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15187 if(IS_WDI_STATUS_FAILURE(status))
15188 {
15189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15190 "Failure in Update Scan Params EQ WDI API, free all the memory " );
15191 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15192 vos_mem_free(pWdaParams->wdaMsgParam);
15193 vos_mem_free(pWdaParams);
15194 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15195 return CONVERT_WDI2VOS_STATUS(status) ;
15196}
15197#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15198
15199#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
15200/*
15201 * FUNCTION: WDA_RoamOffloadScanReqCallback
15202 *
15203 */
15204void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
15205{
15206 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15207 vos_msg_t vosMsg;
15208 wpt_uint8 reason = 0;
15209
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]15210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15211 "<------ %s " ,__func__);
15212 if (NULL == pWdaParams)
15213 {
15214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15215 "%s: pWdaParams received NULL", __func__);
15216 VOS_ASSERT(0) ;
15217 return ;
15218 }
15219 if ( pWdaParams != NULL )
15220 {
15221 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
15222 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15223 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15224 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15225 }
15226 if ( pWdaParams->wdaMsgParam != NULL)
15227 {
15228 vos_mem_free(pWdaParams->wdaMsgParam);
15229 }
15230
15231 vos_mem_free(pWdaParams) ;
15232 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15233 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
15234 vosMsg.bodyptr = NULL;
15235 if (WDI_STATUS_SUCCESS != status)
15236 {
15237 reason = 0;
15238 }
15239 vosMsg.bodyval = reason;
15240 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15241 {
15242 /* free the mem and return */
15243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]15244 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15245 }
15246
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15247 return ;
15248}
15249#endif
15250
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15251/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15252 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15253 *
15254 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15255void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15256{
15257 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15258
15259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15260 "<------ %s " ,__func__);
15261
15262 if(NULL == pWdaParams)
15263 {
15264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15265 "%s: pWdaParams received NULL", __func__);
15266 VOS_ASSERT(0);
15267 return;
15268 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15269
15270 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15271 vos_mem_free(pWdaParams->wdaMsgParam);
15272 vos_mem_free(pWdaParams);
15273
15274 return;
15275}
15276/*
15277 * FUNCTION: WDA_SetPowerParamsReqCallback
15278 * Free memory.
15279 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15280 */
15281void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15282{
15283 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15284
15285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15286 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15287
15288 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15289 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15291 "%s: pWdaParams received NULL", __func__);
15292 VOS_ASSERT(0);
15293 return;
15294 }
15295
15296 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15297 {
15298 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15299 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15300 vos_mem_free(pWdaParams);
15301 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15302
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15303 return;
15304}
15305
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15306#ifdef WLAN_FEATURE_PACKET_FILTERING
15307/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15308 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15309 *
15310 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15311void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15312 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15313 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15314{
15315 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15317 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15318 if(NULL == pWdaParams)
15319 {
15320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15321 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15322 VOS_ASSERT(0) ;
15323 return ;
15324 }
15325
15326 vos_mem_free(pWdaParams->wdaMsgParam) ;
15327 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15328 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15329 //print a msg, nothing else to do
15330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15331 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15332 return ;
15333}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15334/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15335 * FUNCTION: WDA_8023MulticastListReqCallback
15336 * Free memory.
15337 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15338 */
15339void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15340{
15341 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15342
15343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15344 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15345
15346 if(NULL == pWdaParams)
15347 {
15348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15349 "%s: pWdaParams received NULL", __func__);
15350 VOS_ASSERT(0);
15351 return;
15352 }
15353
15354 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15355 {
15356 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15357 vos_mem_free(pWdaParams->wdaMsgParam);
15358 vos_mem_free(pWdaParams);
15359 }
15360
15361 return;
15362}
15363/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15364 * FUNCTION: WDA_Process8023MulticastListReq
15365 * Request to WDI to add 8023 Multicast List
15366 */
15367VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15368 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15369{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15370 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15371 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15372 tWDA_ReqParams *pWdaParams ;
15373 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15375 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15376 pwdiFltPktSetMcListReqParamsType =
15377 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15378 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15379 ) ;
15380 if(NULL == pwdiFltPktSetMcListReqParamsType)
15381 {
15382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15383 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15384 return VOS_STATUS_E_NOMEM;
15385 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15386 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15387 if(NULL == pWdaParams)
15388 {
15389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15390 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15391 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15392 return VOS_STATUS_E_NOMEM;
15393 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15394
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15395 //
15396 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15397 //
15398 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15399 pRcvFltMcAddrList->ulMulticastAddrCnt;
15400
15401 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15402 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15403 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15404 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15405
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15406 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15407 {
15408 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15409 &(pRcvFltMcAddrList->multicastAddr[i]),
15410 sizeof(tSirMacAddr));
15411 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15412 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15413 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15414
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15415 /* Store Params pass it to WDI */
15416 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15417 pWdaParams->pWdaContext = pWDA;
15418 /* Store param pointer as passed in by caller */
15419 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15420 status = WDI_8023MulticastListReq(
15421 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15422 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15423 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15424 if(IS_WDI_STATUS_FAILURE(status))
15425 {
15426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15427 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15428 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15429 vos_mem_free(pWdaParams->wdaMsgParam);
15430 vos_mem_free(pWdaParams);
15431 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15432 return CONVERT_WDI2VOS_STATUS(status) ;
15433}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15434/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15435 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15436 *
15437 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15438void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15439 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15440 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15441{
15442 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15444 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15445 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15446 if(NULL == pWdaParams)
15447 {
15448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15449 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15450 VOS_ASSERT(0) ;
15451 return ;
15452 }
15453
15454 vos_mem_free(pWdaParams->wdaMsgParam) ;
15455 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15456 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15457 //print a msg, nothing else to do
15458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15459 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15460 return ;
15461}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15462
15463/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15464 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15465 * Free memory.
15466 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15467 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15468void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15469 void* pUserData)
15470{
15471 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15472
15473 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15474 "<------ %s, wdiStatus: %d",
15475 __func__, wdiStatus);
15476
15477 if (NULL == pWdaParams)
15478 {
15479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15480 "%s: Invalid pWdaParams pointer", __func__);
15481 VOS_ASSERT(0);
15482 return;
15483 }
15484
15485 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15486 {
15487 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15488 vos_mem_free(pWdaParams->wdaMsgParam);
15489 vos_mem_free(pWdaParams);
15490 }
15491
15492 return;
15493}
15494
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15495/*
15496 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15497 * Request to WDI to set Receive Filters
15498 */
15499VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15500 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15501{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15502 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15503 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15504 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15505 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15506 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15507 tWDA_ReqParams *pWdaParams ;
15508 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15510 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15511 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15512 {
15513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15514 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15515 VOS_ASSERT(0);
15516 return VOS_STATUS_E_NOMEM;
15517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15518 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15519 if(NULL == pWdaParams)
15520 {
15521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15522 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15523 VOS_ASSERT(0);
15524 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15525 return VOS_STATUS_E_NOMEM;
15526 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15527 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15528 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15529 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15530 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15531 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15532 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15533
15534 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15535 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15536
15537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15538 "FID %d FT %d NParams %d CT %d",
15539 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15540 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15541 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15542 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15543 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15544 {
15545 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15546 &pRcvPktFilterCfg->paramsData[i],
15547 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15549 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15550 pwdiSetRcvPktFilterReqParamsType->
15551 wdiPktFilterCfg.paramsData[i].protocolLayer,
15552 pwdiSetRcvPktFilterReqParamsType->
15553 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15555 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15556 pwdiSetRcvPktFilterReqParamsType->
15557 wdiPktFilterCfg.paramsData[i].dataOffset,
15558 pwdiSetRcvPktFilterReqParamsType->
15559 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15561 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15562 pwdiSetRcvPktFilterReqParamsType->
15563 wdiPktFilterCfg.paramsData[i].compareData[0],
15564 pwdiSetRcvPktFilterReqParamsType->
15565 wdiPktFilterCfg.paramsData[i].compareData[1],
15566 pwdiSetRcvPktFilterReqParamsType->
15567 wdiPktFilterCfg.paramsData[i].compareData[2],
15568 pwdiSetRcvPktFilterReqParamsType->
15569 wdiPktFilterCfg.paramsData[i].compareData[3],
15570 pwdiSetRcvPktFilterReqParamsType->
15571 wdiPktFilterCfg.paramsData[i].compareData[4],
15572 pwdiSetRcvPktFilterReqParamsType->
15573 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15574 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15575 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15576 pwdiSetRcvPktFilterReqParamsType->
15577 wdiPktFilterCfg.paramsData[i].dataMask[0],
15578 pwdiSetRcvPktFilterReqParamsType->
15579 wdiPktFilterCfg.paramsData[i].dataMask[1],
15580 pwdiSetRcvPktFilterReqParamsType->
15581 wdiPktFilterCfg.paramsData[i].dataMask[2],
15582 pwdiSetRcvPktFilterReqParamsType->
15583 wdiPktFilterCfg.paramsData[i].dataMask[3],
15584 pwdiSetRcvPktFilterReqParamsType->
15585 wdiPktFilterCfg.paramsData[i].dataMask[4],
15586 pwdiSetRcvPktFilterReqParamsType->
15587 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15588 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15589 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15590 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15591 /* Store Params pass it to WDI */
15592 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15593 pWdaParams->pWdaContext = pWDA;
15594 /* Store param pointer as passed in by caller */
15595 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15596 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15597 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15598 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15599 if(IS_WDI_STATUS_FAILURE(status))
15600 {
15601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15602 "Failure in SetFilter(),free all the memory,status %d ",status);
15603 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15604 vos_mem_free(pWdaParams->wdaMsgParam);
15605 vos_mem_free(pWdaParams);
15606 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15607 return CONVERT_WDI2VOS_STATUS(status) ;
15608}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15609/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15610 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15611 *
15612 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15613void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15614 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15615 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15616{
15617 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15618 tWDA_CbContext *pWDA;
15619 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15620 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15621 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15622 tANI_U8 i;
15623 vos_msg_t vosMsg;
15624
15625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15626 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15627 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15628
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15629 if(NULL == pRcvFltPktMatchCntRsp)
15630 {
15631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15632 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15633 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15634 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15635 return ;
15636 }
15637
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15638 if(NULL == pWdaParams)
15639 {
15640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15641 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15642 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15643 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15644 return ;
15645 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15646 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15647 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15648 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15649 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15650
15651 /* Message Header */
15652 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15653 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15654
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15655 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15656
15657 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15658 {
15659 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15660 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15662 /* VOS message wrapper */
15663 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15664 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15665 vosMsg.bodyval = 0;
15666 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15667 {
15668 /* free the mem and return */
15669 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15670 }
15671
15672 vos_mem_free(pWdaParams->wdaMsgParam) ;
15673 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15674 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15675
15676 return;
15677}
15678/*
15679 * FUNCTION: WDA_FilterMatchCountReqCallback
15680 * Free memory and send RSP back to SME.
15681 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15682 */
15683void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15684{
15685 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15686 vos_msg_t vosMsg;
15687
15688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15689 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15690
15691 if(NULL == pWdaParams)
15692 {
15693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15694 "%s: pWdaParams received NULL", __func__);
15695 VOS_ASSERT(0);
15696 return;
15697 }
15698
15699 /* VOS message wrapper */
15700 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15701 vosMsg.bodyptr = NULL;
15702 vosMsg.bodyval = 0;
15703
15704 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15705 {
15706 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15707 vos_mem_free(pWdaParams->wdaMsgParam);
15708 vos_mem_free(pWdaParams);
15709 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15710 }
15711
15712 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15713}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15714/*
15715 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15716 * Request to WDI to get PC Filter Match Count
15717 */
15718VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15719{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15720 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15721 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15722 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15723 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15725 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15726 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15727 {
15728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15729 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15730 VOS_ASSERT(0);
15731 return VOS_STATUS_E_NOMEM;
15732 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15733 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15734 if(NULL == pWdaParams)
15735 {
15736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15737 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15738 VOS_ASSERT(0);
15739 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15740 return VOS_STATUS_E_NOMEM;
15741 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15742
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15743 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15744 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15745
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15746 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15747 pRcvFltPktMatchRsp->bssId,
15748 sizeof(wpt_macAddr));
15749
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15750 /* Store Params pass it to WDI */
15751 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15752 pWdaParams->pWdaContext = pWDA;
15753 /* Store param pointer as passed in by caller */
15754 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15755 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15756 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15757 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15758 if(IS_WDI_STATUS_FAILURE(status))
15759 {
15760 /* failure returned by WDI API */
15761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15762 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15763 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15764 vos_mem_free(pWdaParams) ;
15765 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15766 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15768 return CONVERT_WDI2VOS_STATUS(status) ;
15769}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15770/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15771 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15772 *
15773 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15774void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15775 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15776 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15777{
15778 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15780 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15781/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15782 if(NULL == pWdaParams)
15783 {
15784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15785 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15786 VOS_ASSERT(0) ;
15787 return ;
15788 }
15789
15790 vos_mem_free(pWdaParams->wdaMsgParam) ;
15791 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15792 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15793 //print a msg, nothing else to do
15794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15795 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15796 return ;
15797}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15798/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15799 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15800 * Free memory.
15801 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15802 */
15803void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15804{
15805 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15806
15807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15808 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15809
15810 if(NULL == pWdaParams)
15811 {
15812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15813 "%s: Invalid pWdaParams pointer", __func__);
15814 VOS_ASSERT(0);
15815 return;
15816 }
15817
15818 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15819 {
15820 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15821 vos_mem_free(pWdaParams->wdaMsgParam);
15822 vos_mem_free(pWdaParams);
15823 }
15824
15825 return;
15826}
15827/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15828 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15829 * Request to WDI to clear Receive Filters
15830 */
15831VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15832 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15833{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15834 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15835 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15836 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15837 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15839 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15840 if(NULL == pwdiRcvFltPktClearReqParamsType)
15841 {
15842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15843 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15844 VOS_ASSERT(0);
15845 return VOS_STATUS_E_NOMEM;
15846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15847 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15848 if(NULL == pWdaParams)
15849 {
15850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15851 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15852 VOS_ASSERT(0);
15853 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15854 return VOS_STATUS_E_NOMEM;
15855 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15856 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
15857 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15858 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
15859 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
15860 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
15861 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15862
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15863 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15864 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15865 /* Store Params pass it to WDI */
15866 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
15867 pWdaParams->pWdaContext = pWDA;
15868 /* Store param pointer as passed in by caller */
15869 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15870 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15871 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15872 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15873 if(IS_WDI_STATUS_FAILURE(status))
15874 {
15875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15876 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
15877 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]15878 vos_mem_free(pWdaParams->wdaMsgParam);
15879 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15880 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15881 return CONVERT_WDI2VOS_STATUS(status) ;
15882}
15883#endif // WLAN_FEATURE_PACKET_FILTERING
15884
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15885/*
15886 * FUNCTION: WDA_ProcessSetPowerParamsReq
15887 * Request to WDI to set power params
15888 */
15889VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
15890 tSirSetPowerParamsReq *pPowerParams)
15891{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15892 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15893 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
15894 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15895 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15897 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15898 if(NULL == pwdiSetPowerParamsReqInfo)
15899 {
15900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15901 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15902 VOS_ASSERT(0);
15903 return VOS_STATUS_E_NOMEM;
15904 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15905 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15906 if(NULL == pWdaParams)
15907 {
15908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15909 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15910 VOS_ASSERT(0);
15911 vos_mem_free(pwdiSetPowerParamsReqInfo);
15912 return VOS_STATUS_E_NOMEM;
15913 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15914
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15915
15916 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
15917 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15918 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
15919 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15920 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
15921 pPowerParams->uListenInterval;
15922 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
15923 pPowerParams->uBcastMcastFilter;
15924 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
15925 pPowerParams->uEnableBET;
15926 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
15927 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]15928 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
15929 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15930 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
15931 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15932
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15933 /* Store Params pass it to WDI */
15934 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
15935 pWdaParams->pWdaContext = pWDA;
15936 /* Store param pointer as passed in by caller */
15937 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15938 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15939 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15940 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15941 if(IS_WDI_STATUS_FAILURE(status))
15942 {
15943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15944 "Failure in Set power params REQ WDI API, free all the memory " );
15945 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15946 vos_mem_free(pWdaParams->wdaMsgParam);
15947 pWdaParams->wdaWdiApiMsgParam = NULL;
15948 pWdaParams->wdaMsgParam = NULL;
15949 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15950 return CONVERT_WDI2VOS_STATUS(status) ;
15951}
15952
15953/*
15954 * FUNCTION: WDA_SetTmLevelRspCallback
15955 * Set TM Level response
15956 */
15957void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
15958{
15959 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15960
15961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15962 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15963
15964 if(NULL == pWdaParams)
15965 {
15966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15967 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15968 VOS_ASSERT(0) ;
15969 return ;
15970 }
15971
15972 /* Dose not need to send notification to upper layer
15973 * Just free allocated resources */
15974 if( pWdaParams != NULL )
15975 {
15976 if( pWdaParams->wdaWdiApiMsgParam != NULL )
15977 {
15978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15979 }
15980 vos_mem_free(pWdaParams->wdaMsgParam) ;
15981 vos_mem_free(pWdaParams) ;
15982 }
15983}
15984
15985/*
15986 * FUNCTION: WDA_ProcessSetTmLevelReq
15987 * Set TM Level request
15988 */
15989VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
15990 tAniSetTmLevelReq *setTmLevelReq)
15991{
15992 WDI_Status status = WDI_STATUS_SUCCESS ;
15993 tWDA_ReqParams *pWdaParams ;
15994 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
15995 (WDI_SetTmLevelReqType *)vos_mem_malloc(
15996 sizeof(WDI_SetTmLevelReqType)) ;
15997 if(NULL == wdiSetTmLevelReq)
15998 {
15999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16000 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16001 VOS_ASSERT(0);
16002 return VOS_STATUS_E_NOMEM;
16003 }
16004
16005 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16006 if(NULL == pWdaParams)
16007 {
16008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16009 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16010 VOS_ASSERT(0);
16011 vos_mem_free(wdiSetTmLevelReq);
16012 return VOS_STATUS_E_NOMEM;
16013 }
16014
16015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16016 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16017
16018 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
16019 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
16020
16021 pWdaParams->pWdaContext = pWDA;
16022 pWdaParams->wdaMsgParam = setTmLevelReq;
16023 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
16024
16025 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
16026 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
16027
16028 if(IS_WDI_STATUS_FAILURE(status))
16029 {
16030 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]16031 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16032 vos_mem_free(pWdaParams->wdaMsgParam) ;
16033 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16034 vos_mem_free(pWdaParams) ;
16035 }
16036
16037 return CONVERT_WDI2VOS_STATUS(status) ;
16038}
16039
16040VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
16041 tpTxControlParams pTxCtrlParam)
16042{
16043 VOS_STATUS wdaStatus;
16044
16045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16046 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16047 if( pTxCtrlParam == NULL )
16048 {
16049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16050 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16051 return VOS_STATUS_E_FAILURE;
16052 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16053 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
16054 {
16055 wdaStatus = WDA_SuspendDataTx(pWDA);
16056 }
16057 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
16058 {
16059 wdaStatus = WDA_ResumeDataTx(pWDA);
16060 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16061 return wdaStatus;
16062}
16063
16064 /* FUNCTION WDA_featureCapsExchange
16065 * WDA API to invoke capability exchange between host and FW.
16066 */
16067void WDA_featureCapsExchange(v_PVOID_t pVosContext)
16068{
16069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16070 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16071 WDI_featureCapsExchangeReq( NULL, pVosContext);
16072}
16073
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]16074/* FUNCTION WDA_disableCapablityFeature
16075 * WDA API to diable Active mode offload in host.
16076 */
16077void WDA_disableCapablityFeature(tANI_U8 feature_index)
16078{
16079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16080 "%s:enter", __func__ );
16081 WDI_disableCapablityFeature(feature_index);
16082}
16083
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16084 /* FUNCTION WDA_getHostWlanFeatCaps
16085 * Wrapper for WDI API, that will return if the feature (enum value).passed
16086 * to this API is supported or not in Host
16087 * return value
16088 * 0 - implies feature is NOT Supported
16089 * any non zero value - implies feature is SUPPORTED
16090 */
16091tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
16092{
16093 return WDI_getHostWlanFeatCaps(featEnumValue);
16094}
16095
16096 /* FUNCTION WDA_getFwWlanFeatCaps
16097 * Wrapper for WDI API, that will return if the feature (enum value).passed
16098 * to this API is supported or not in FW
16099 * return value
16100 * 0 - implies feature is NOT Supported
16101 * any non zero value - implies feature is SUPPORTED
16102 */
16103tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
16104{
16105 return WDI_getFwWlanFeatCaps(featEnumValue);
16106}
16107
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]16108
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16109/*
16110 * FUNCTION: WDA_shutdown
16111 * Shutdown WDA/WDI without handshaking with Riva.
16112 * Synchronous function.
16113 */
16114VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
16115{
16116 WDI_Status wdiStatus;
16117 //tANI_U8 eventIdx = 0;
16118 VOS_STATUS status = VOS_STATUS_SUCCESS;
16119 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16120 if (NULL == pWDA)
16121 {
16122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16123 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16124 VOS_ASSERT(0);
16125 return VOS_STATUS_E_FAILURE;
16126 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16127 /* FTM mode stay START_STATE */
16128 if( (WDA_READY_STATE != pWDA->wdaState) &&
16129 (WDA_INIT_STATE != pWDA->wdaState) &&
16130 (WDA_START_STATE != pWDA->wdaState) )
16131 {
16132 VOS_ASSERT(0);
16133 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16134
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16135 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
16136 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16137 {
16138 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16139 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16140 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]16141 else
16142 {
16143 vos_event_destroy(&pWDA->ftmStopDoneEvent);
16144 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16146 /* call WDI shutdown */
16147 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16148 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
16149 {
16150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16151 "error in WDA Stop" );
16152 status = VOS_STATUS_E_FAILURE;
16153 }
16154 /* WDI stop is synchrnous, shutdown is complete when it returns */
16155 pWDA->wdaState = WDA_STOP_STATE;
16156
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16157 /* shutdown should perform the stop & close actions. */
16158 /* Destroy the event */
16159 status = vos_event_destroy(&pWDA->txFrameEvent);
16160 if(!VOS_IS_STATUS_SUCCESS(status))
16161 {
16162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16163 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16164 status = VOS_STATUS_E_FAILURE;
16165 }
16166 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
16167 if(!VOS_IS_STATUS_SUCCESS(status))
16168 {
16169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16170 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16171 status = VOS_STATUS_E_FAILURE;
16172 }
16173 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
16174 if(!VOS_IS_STATUS_SUCCESS(status))
16175 {
16176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16177 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16178 status = VOS_STATUS_E_FAILURE;
16179 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16180 /* free WDA context */
16181 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
16182 if ( !VOS_IS_STATUS_SUCCESS(status) )
16183 {
16184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16185 "error in WDA close " );
16186 status = VOS_STATUS_E_FAILURE;
16187 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16188 return status;
16189}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16190
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16191/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16192 * FUNCTION: WDA_setNeedShutdown
16193 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16194 */
16195
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16196void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16197{
16198 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16199 if(pWDA == NULL)
16200 {
16201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16202 "Could not get the WDA Context pointer" );
16203 return;
16204 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16205 pWDA->needShutdown = TRUE;
16206}
16207/*
16208 * FUNCTION: WDA_needShutdown
16209 * WDA needs a shutdown
16210 */
16211
16212v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
16213{
16214 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16215 if(pWDA == NULL)
16216 {
16217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16218 "Could not get the WDA Context pointer" );
16219 return 0;
16220 }
16221 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16222}
16223
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16224#ifdef WLAN_FEATURE_11AC
16225/*
16226 * FUNCTION: WDA_SetBeaconFilterReqCallback
16227 *
16228 */
16229void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
16230{
16231 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16233 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16234 if(NULL == pWdaParams)
16235 {
16236 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16237 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16238 VOS_ASSERT(0) ;
16239 return ;
16240 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16241
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16242 vos_mem_free(pWdaParams->wdaMsgParam) ;
16243 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16244 vos_mem_free(pWdaParams) ;
16245 /*
16246 * No respone required for SetBeaconFilter req so just free the request
16247 * param here
16248 */
16249
16250 return ;
16251}
16252
16253VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
16254 tUpdateVHTOpMode *pData)
16255{
16256 WDI_Status status = WDI_STATUS_SUCCESS ;
16257 tWDA_ReqParams *pWdaParams ;
16258 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
16259 sizeof(WDI_UpdateVHTOpMode)) ;
16260 if(NULL == wdiTemp)
16261 {
16262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16263 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16264 VOS_ASSERT(0);
16265 return VOS_STATUS_E_NOMEM;
16266 }
16267 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16268 if(NULL == pWdaParams)
16269 {
16270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16271 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16272 VOS_ASSERT(0);
16273 vos_mem_free(wdiTemp);
16274 return VOS_STATUS_E_NOMEM;
16275 }
16276
16277 wdiTemp->opMode = pData->opMode;
16278 wdiTemp->staId = pData->staId;
16279
16280 pWdaParams->pWdaContext = pWDA;
16281 /* Store Req pointer, as this will be used for response */
16282 pWdaParams->wdaMsgParam = (void *)pData;
16283 /* store Params pass it to WDI */
16284 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16285
16286 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16287
16288 if(IS_WDI_STATUS_FAILURE(status))
16289 {
16290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16291 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16293 vos_mem_free(pWdaParams->wdaMsgParam);
16294 vos_mem_free(pWdaParams);
16295 }
16296 return CONVERT_WDI2VOS_STATUS(status) ;
16297}
16298#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16299
16300/*==========================================================================
16301 FUNCTION WDA_TransportChannelDebug
16302
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16303 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16304 Display Transport Channel debugging information
16305 User may request to display DXE channel snapshot
16306 Or if host driver detects any abnormal stcuk may display
16307
16308 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16309 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16310 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16311 debugFlags : Enable stall detect features
16312 defined by WPAL_DeviceDebugFlags
16313 These features may effect
16314 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16315
16316 RETURN VALUE
16317 NONE
16318
16319===========================================================================*/
16320void WDA_TransportChannelDebug
16321(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16322 tpAniSirGlobal pMac,
16323 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16324 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16325)
16326{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16327 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16328 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16329}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16330
16331/*==========================================================================
16332 FUNCTION WDA_SetEnableSSR
16333
16334 DESCRIPTION
16335 API to enable/disable SSR on WDI timeout
16336
16337 PARAMETERS
16338 enableSSR : enable/disable SSR
16339
16340 RETURN VALUE
16341 NONE
16342
16343===========================================================================*/
16344void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16345{
16346 WDI_SetEnableSSR(enableSSR);
16347}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16348
16349#ifdef FEATURE_WLAN_LPHB
16350/*
16351 * FUNCTION: WDA_LPHBconfRspCallback
16352 *
16353 */
16354void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16355{
16356 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16357
16358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16359 "<------ %s " ,__func__);
16360 if (NULL == pWdaParams)
16361 {
16362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16363 "%s: pWdaParams received NULL", __func__);
16364 VOS_ASSERT(0) ;
16365 return ;
16366 }
16367
16368 /* Do not need to send notification to upper layer
16369 * Just free allocated resources */
16370 if (pWdaParams != NULL)
16371 {
16372 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16373 {
16374 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16375 }
16376 vos_mem_free(pWdaParams->wdaMsgParam) ;
16377 vos_mem_free(pWdaParams) ;
16378 }
16379
16380 return;
16381}
16382
16383/*
16384 * FUNCTION: WDA_ProcessLPHBConfReq
16385 *
16386 */
16387VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16388 tSirLPHBReq *pData)
16389{
16390 WDI_Status wdiStatus;
16391 tWDA_ReqParams *pWdaParams ;
16392
16393 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16394 "------> %s " , __func__);
16395
16396 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16397 if (NULL == pWdaParams)
16398 {
16399 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16400 "%s: VOS MEM Alloc Failure", __func__);
16401 VOS_ASSERT(0);
16402 vos_mem_free(pData);
16403 return VOS_STATUS_E_NOMEM;
16404 }
16405
16406 pWdaParams->pWdaContext = pWDA;
16407 pWdaParams->wdaMsgParam = (void *)pData;
16408 pWdaParams->wdaWdiApiMsgParam = NULL;
16409
16410 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16411 if (WDI_STATUS_PENDING == wdiStatus)
16412 {
16413 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16414 "Pending received for %s:%d ", __func__, __LINE__);
16415 }
16416 else if (WDI_STATUS_SUCCESS != wdiStatus)
16417 {
16418 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16419 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16420 vos_mem_free(pWdaParams->wdaMsgParam);
16421 vos_mem_free(pWdaParams);
16422 }
16423
16424 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16425}
16426#endif /* FEATURE_WLAN_LPHB */
16427
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16428void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16429 void* pUserData)
16430{
16431 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16432
16433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16434 "<------ %s " ,__func__);
16435 if (NULL == pBcnMissRateInfo)
16436 {
16437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16438 "%s: pWdaParams received NULL", __func__);
16439 VOS_ASSERT(0) ;
16440 return ;
16441 }
16442 if (pBcnMissRateInfo->callback)
16443 {
16444 pBcnMissRateInfo->callback(status, bcnMissRate,
16445 pBcnMissRateInfo->data);
16446 }
16447 vos_mem_free(pUserData);
16448
16449 return;
16450}
16451
16452v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16453 tSirBcnMissRateReq *pData)
16454{
16455 WDI_Status wdiStatus;
16456 tSirBcnMissRateInfo *pBcnMissRateInfo;
16457
16458 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16459 "------> %s " , __func__);
16460
16461 pBcnMissRateInfo =
16462 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16463 if (NULL == pBcnMissRateInfo)
16464 {
16465 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16466 "%s: VOS MEM Alloc Failure", __func__);
16467 VOS_ASSERT(0);
16468 vos_mem_free(pData);
16469 return;
16470 }
16471
16472 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16473 pBcnMissRateInfo->data = pData->data;
16474
16475 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16476 WDA_GetBcnMissRateCallback,
16477 pData->bssid);
16478 if (WDI_STATUS_PENDING == wdiStatus)
16479 {
16480 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16481 "Pending received for %s:%d ", __func__, __LINE__);
16482 }
16483 else if (WDI_STATUS_SUCCESS != wdiStatus)
16484 {
16485 if (pBcnMissRateInfo->callback)
16486 {
16487 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16488 -1, pBcnMissRateInfo->data);
16489 }
16490 }
16491 vos_mem_free(pData);
16492}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16493
16494#ifdef WLAN_FEATURE_EXTSCAN
16495
16496/*==========================================================================
16497 FUNCTION WDA_EXTScanStartRspCallback
16498
16499 DESCRIPTION
16500 API to send EXTScan Start Response to HDD
16501
16502 PARAMETERS
16503 pEventData: Response from FW
16504 pUserData:
16505===========================================================================*/
16506void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16507{
16508 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16509 tWDA_CbContext *pWDA = NULL;
16510 void *pCallbackContext;
16511 tpAniSirGlobal pMac;
16512
16513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16514 "%s:", __func__);
16515 if (NULL == pWdaParams)
16516 {
16517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16518 "%s: pWdaParams received NULL", __func__);
16519 VOS_ASSERT(0);
16520 return;
16521 }
16522
16523 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16524
16525 if (NULL == pWDA)
16526 {
16527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16528 "%s: pWDA received NULL", __func__);
16529 VOS_ASSERT(0);
16530 goto error;
16531 }
16532
16533 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16534 if (NULL == pMac)
16535 {
16536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16537 "%s:pMac is NULL", __func__);
16538 VOS_ASSERT(0);
16539 goto error;
16540 }
16541
16542 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16543
16544 if (pMac->sme.pEXTScanIndCb)
16545 {
16546 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16547 pEventData);
16548 }
16549 else
16550 {
16551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16552 "%s:HDD callback is null", __func__);
16553 VOS_ASSERT(0);
16554 }
16555
16556error:
16557
16558 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16559 {
16560 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16561 }
16562 if (pWdaParams->wdaMsgParam != NULL)
16563 {
16564 vos_mem_free(pWdaParams->wdaMsgParam);
16565 }
16566 vos_mem_free(pWdaParams) ;
16567
16568 return;
16569}
16570
16571/*==========================================================================
16572 FUNCTION WDA_EXTScanStopRspCallback
16573
16574 DESCRIPTION
16575 API to send EXTScan Stop Response to HDD
16576
16577 PARAMETERS
16578 pEventData: Response from FW
16579 pUserData:
16580===========================================================================*/
16581void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16582{
16583 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16584 tWDA_CbContext *pWDA = NULL;
16585 void *pCallbackContext;
16586 tpAniSirGlobal pMac;
16587
16588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16589 "%s:", __func__);
16590 if (NULL == pWdaParams)
16591 {
16592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16593 "%s: pWdaParams received NULL", __func__);
16594 VOS_ASSERT(0);
16595 return;
16596 }
16597
16598 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16599
16600 if (NULL == pWDA)
16601 {
16602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16603 "%s: pWDA received NULL", __func__);
16604 VOS_ASSERT(0);
16605 goto error;
16606 }
16607
16608 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16609 if (NULL == pMac)
16610 {
16611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16612 "%s:pMac is NULL", __func__);
16613 VOS_ASSERT(0);
16614 goto error;
16615 }
16616 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16617
16618 if (pMac->sme.pEXTScanIndCb)
16619 {
16620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16621 "%s:HDD call back function called", __func__);
16622 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16623 pEventData);
16624 }
16625 else
16626 {
16627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16628 "%s:HDD callback is null", __func__);
16629 VOS_ASSERT(0);
16630 }
16631
16632error:
16633
16634 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16635 {
16636 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16637 }
16638 if (pWdaParams->wdaMsgParam != NULL)
16639 {
16640 vos_mem_free(pWdaParams->wdaMsgParam);
16641 }
16642 vos_mem_free(pWdaParams) ;
16643
16644
16645 return;
16646}
16647
16648/*==========================================================================
16649 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16650
16651 DESCRIPTION
16652 API to send EXTScan Get Cached Results Response to HDD
16653
16654 PARAMETERS
16655 pEventData: Response from FW
16656 pUserData:
16657===========================================================================*/
16658void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16659{
16660 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16661 tWDA_CbContext *pWDA = NULL;
16662 void *pCallbackContext;
16663 tpAniSirGlobal pMac;
16664
16665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16666 "%s: ", __func__);
16667 if (NULL == pWdaParams)
16668 {
16669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16670 "%s: pWdaParams received NULL", __func__);
16671 VOS_ASSERT(0);
16672 return;
16673 }
16674
16675 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16676
16677 if (NULL == pWDA)
16678 {
16679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16680 "%s: pWDA received NULL", __func__);
16681 VOS_ASSERT(0);
16682 goto error;
16683 }
16684
16685 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16686 if (NULL == pMac)
16687 {
16688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16689 "%s:pMac is NULL", __func__);
16690 VOS_ASSERT(0);
16691 goto error;
16692 }
16693
16694 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16695
16696 if (pMac->sme.pEXTScanIndCb)
16697 {
16698 pMac->sme.pEXTScanIndCb(pCallbackContext,
16699 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16700 pEventData);
16701 }
16702 else
16703 {
16704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16705 "%s:HDD callback is null", __func__);
16706 VOS_ASSERT(0);
16707 }
16708
16709
16710error:
16711
16712 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16713 {
16714 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16715 }
16716 if (pWdaParams->wdaMsgParam != NULL)
16717 {
16718 vos_mem_free(pWdaParams->wdaMsgParam);
16719 }
16720 vos_mem_free(pWdaParams) ;
16721
16722 return;
16723}
16724
16725/*==========================================================================
16726 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16727
16728 DESCRIPTION
16729 API to send EXTScan Get Capabilities Response to HDD
16730
16731 PARAMETERS
16732 pEventData: Response from FW
16733 pUserData:
16734===========================================================================*/
16735void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16736{
16737 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16738 tWDA_CbContext *pWDA = NULL;
16739 void *pCallbackContext;
16740 tpAniSirGlobal pMac;
16741
16742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16743 "%s:", __func__);
16744 if (NULL == pWdaParams)
16745 {
16746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16747 "%s: pWdaParams received NULL", __func__);
16748 VOS_ASSERT(0);
16749 return;
16750 }
16751
16752 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16753
16754 if (NULL == pWDA)
16755 {
16756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16757 "%s: pWDA received NULL", __func__);
16758 VOS_ASSERT(0);
16759 goto error;
16760 }
16761
16762 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16763 if (NULL == pMac)
16764 {
16765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16766 "%s:pMac is NULL", __func__);
16767 VOS_ASSERT(0);
16768 goto error;
16769 }
16770
16771 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16772
16773 if (pMac->sme.pEXTScanIndCb)
16774 {
16775 pMac->sme.pEXTScanIndCb(pCallbackContext,
16776 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16777 pEventData);
16778 }
16779 else
16780 {
16781 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16782 "%s:HDD callback is null", __func__);
16783 VOS_ASSERT(0);
16784 }
16785
16786
16787error:
16788
16789 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16790 {
16791 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16792 }
16793 if (pWdaParams->wdaMsgParam != NULL)
16794 {
16795 vos_mem_free(pWdaParams->wdaMsgParam);
16796 }
16797 vos_mem_free(pWdaParams) ;
16798
16799 return;
16800}
16801
16802/*==========================================================================
16803 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16804
16805 DESCRIPTION
16806 API to send EXTScan Set BSSID Hotlist Response to HDD
16807
16808 PARAMETERS
16809 pEventData: Response from FW
16810 pUserData:
16811===========================================================================*/
16812void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16813{
16814 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16815 tWDA_CbContext *pWDA = NULL;
16816 void *pCallbackContext;
16817 tpAniSirGlobal pMac;
16818
16819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16820 "%s: ", __func__);
16821 if (NULL == pWdaParams)
16822 {
16823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16824 "%s: pWdaParams received NULL", __func__);
16825 VOS_ASSERT(0) ;
16826 return;
16827 }
16828
16829 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16830
16831 if (NULL == pWDA)
16832 {
16833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16834 "%s: pWDA received NULL", __func__);
16835 VOS_ASSERT(0);
16836 goto error;
16837 }
16838
16839 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16840 if (NULL == pMac)
16841 {
16842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16843 "%s:pMac is NULL", __func__);
16844 VOS_ASSERT(0);
16845 goto error;
16846 }
16847
16848 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16849
16850 if (pMac->sme.pEXTScanIndCb)
16851 {
16852 pMac->sme.pEXTScanIndCb(pCallbackContext,
16853 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16854 pEventData);
16855 }
16856 else
16857 {
16858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16859 "%s:HDD callback is null", __func__);
16860 VOS_ASSERT(0);
16861 }
16862
16863
16864error:
16865
16866 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16867 {
16868 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16869 }
16870 if (pWdaParams->wdaMsgParam != NULL)
16871 {
16872 vos_mem_free(pWdaParams->wdaMsgParam);
16873 }
16874 vos_mem_free(pWdaParams) ;
16875
16876 return;
16877}
16878
16879/*==========================================================================
16880 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
16881
16882 DESCRIPTION
16883 API to send EXTScan ReSet BSSID Hotlist Response to HDD
16884
16885 PARAMETERS
16886 pEventData: Response from FW
16887 pUserData:
16888===========================================================================*/
16889void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16890{
16891 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16892 tWDA_CbContext *pWDA = NULL;
16893 void *pCallbackContext;
16894 tpAniSirGlobal pMac;
16895
16896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16897 "%s:", __func__);
16898 if (NULL == pWdaParams)
16899 {
16900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16901 "%s: pWdaParams received NULL", __func__);
16902 VOS_ASSERT(0) ;
16903 return;
16904 }
16905
16906 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16907
16908 if (NULL == pWDA)
16909 {
16910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16911 "%s: pWDA received NULL", __func__);
16912 VOS_ASSERT(0);
16913 goto error;
16914 }
16915
16916 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16917 if (NULL == pMac)
16918 {
16919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16920 "%s:pMac is NULL", __func__);
16921 VOS_ASSERT(0);
16922 goto error;
16923 }
16924
16925 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16926
16927 if (pMac->sme.pEXTScanIndCb)
16928 {
16929 pMac->sme.pEXTScanIndCb(pCallbackContext,
16930 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
16931 pEventData);
16932 }
16933 else
16934 {
16935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16936 "%s:HDD callback is null", __func__);
16937 VOS_ASSERT(0);
16938 }
16939
16940
16941error:
16942
16943 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16944 {
16945 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16946 }
16947 if (pWdaParams->wdaMsgParam != NULL)
16948 {
16949 vos_mem_free(pWdaParams->wdaMsgParam);
16950 }
16951 vos_mem_free(pWdaParams) ;
16952
16953 return;
16954}
16955
16956/*==========================================================================
16957 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
16958
16959 DESCRIPTION
16960 API to send EXTScan Set Significant RSSI Change RSP to HDD
16961
16962 PARAMETERS
16963 pEventData: Response from FW
16964 pUserData:
16965===========================================================================*/
16966void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
16967{
16968 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16969 tWDA_CbContext *pWDA = NULL;
16970 void *pCallbackContext;
16971 tpAniSirGlobal pMac;
16972
16973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16974 "%s:", __func__);
16975 if (NULL == pWdaParams)
16976 {
16977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16978 "%s: pWdaParams received NULL", __func__);
16979 VOS_ASSERT(0) ;
16980 return;
16981 }
16982
16983 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16984
16985 if (NULL == pWDA)
16986 {
16987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16988 "%s: pWDA received NULL", __func__);
16989 VOS_ASSERT(0);
16990 goto error;
16991 }
16992
16993 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16994 if (NULL == pMac)
16995 {
16996 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16997 "%s:pMac is NULL", __func__);
16998 VOS_ASSERT(0);
16999 goto error;
17000 }
17001
17002 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17003
17004 if (pMac->sme.pEXTScanIndCb)
17005 {
17006 pMac->sme.pEXTScanIndCb(pCallbackContext,
17007 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
17008 pEventData);
17009 }
17010 else
17011 {
17012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17013 "%s:HDD callback is null", __func__);
17014 VOS_ASSERT(0);
17015 }
17016
17017
17018error:
17019
17020 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17021 {
17022 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17023 }
17024 if (pWdaParams->wdaMsgParam != NULL)
17025 {
17026 vos_mem_free(pWdaParams->wdaMsgParam);
17027 }
17028 vos_mem_free(pWdaParams) ;
17029
17030 return;
17031}
17032
17033/*==========================================================================
17034 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
17035
17036 DESCRIPTION
17037 API to send EXTScan Set Significant RSSI Change RSP to HDD
17038
17039 PARAMETERS
17040 pEventData: Response from FW
17041 pUserData:
17042===========================================================================*/
17043void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
17044 void* pUserData)
17045{
17046 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17047 tWDA_CbContext *pWDA = NULL;
17048 void *pCallbackContext;
17049 tpAniSirGlobal pMac;
17050
17051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17052 "%s:", __func__);
17053 if (NULL == pWdaParams)
17054 {
17055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17056 "%s: pWdaParams received NULL", __func__);
17057 VOS_ASSERT(0) ;
17058 return;
17059 }
17060
17061 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17062
17063 if (NULL == pWDA)
17064 {
17065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17066 "%s: pWDA received NULL", __func__);
17067 VOS_ASSERT(0);
17068 goto error;
17069 }
17070
17071 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17072 if (NULL == pMac)
17073 {
17074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17075 "%s:pMac is NULL", __func__);
17076 VOS_ASSERT(0);
17077 goto error;
17078 }
17079
17080 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17081
17082 if (pMac->sme.pEXTScanIndCb)
17083 {
17084 pMac->sme.pEXTScanIndCb(pCallbackContext,
17085 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
17086 pEventData);
17087 }
17088 else
17089 {
17090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17091 "%s:HDD callback is null", __func__);
17092 VOS_ASSERT(0);
17093 }
17094
17095
17096error:
17097
17098 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17099 {
17100 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17101 }
17102 if (pWdaParams->wdaMsgParam != NULL)
17103 {
17104 vos_mem_free(pWdaParams->wdaMsgParam);
17105 }
17106 vos_mem_free(pWdaParams) ;
17107
17108 return;
17109}
17110
17111/*==========================================================================
17112 FUNCTION WDA_ProcessEXTScanStartReq
17113
17114 DESCRIPTION
17115 API to send EXTScan Start Request to WDI
17116
17117 PARAMETERS
17118 pWDA: Pointer to WDA context
17119 wdaRequest: Pointer to EXTScan req parameters
17120===========================================================================*/
17121VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
17122 tSirEXTScanStartReqParams *wdaRequest)
17123{
17124 WDI_Status status = WDI_STATUS_SUCCESS;
17125 tWDA_ReqParams *pWdaParams;
17126
17127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17128 "%s: ", __func__);
17129 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17130 if (NULL == pWdaParams)
17131 {
17132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17133 "%s: VOS MEM Alloc Failure", __func__);
17134 VOS_ASSERT(0);
17135 return VOS_STATUS_E_NOMEM;
17136 }
17137 pWdaParams->pWdaContext = pWDA;
17138 pWdaParams->wdaMsgParam = wdaRequest;
17139 pWdaParams->wdaWdiApiMsgParam = NULL;
17140
17141 status = WDI_EXTScanStartReq((void *)wdaRequest,
17142 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
17143 (void *)pWdaParams);
17144 if (IS_WDI_STATUS_FAILURE(status))
17145 {
17146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17147 "Failure to request. Free all the memory " );
17148 vos_mem_free(pWdaParams->wdaMsgParam);
17149 vos_mem_free(pWdaParams);
17150 }
17151 return CONVERT_WDI2VOS_STATUS(status);
17152}
17153
17154/*==========================================================================
17155 FUNCTION WDA_ProcessEXTScanStopReq
17156
17157 DESCRIPTION
17158 API to send EXTScan Start Request to WDI
17159
17160 PARAMETERS
17161 pWDA: Pointer to WDA context
17162 wdaRequest: Pointer to EXTScan req parameters
17163===========================================================================*/
17164VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
17165 tSirEXTScanStopReqParams *wdaRequest)
17166{
17167 WDI_Status status = WDI_STATUS_SUCCESS;
17168 tWDA_ReqParams *pWdaParams;
17169
17170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17171 "%s:", __func__);
17172 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17173 if (NULL == pWdaParams)
17174 {
17175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17176 "%s: VOS MEM Alloc Failure", __func__);
17177 VOS_ASSERT(0);
17178 return VOS_STATUS_E_NOMEM;
17179 }
17180 pWdaParams->pWdaContext = pWDA;
17181 pWdaParams->wdaMsgParam = wdaRequest;
17182 pWdaParams->wdaWdiApiMsgParam = NULL;
17183
17184 status = WDI_EXTScanStopReq((void *)wdaRequest,
17185 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
17186 (void *)pWdaParams);
17187 if (IS_WDI_STATUS_FAILURE(status))
17188 {
17189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17190 "Failure to request. Free all the memory " );
17191 vos_mem_free(pWdaParams->wdaMsgParam);
17192 vos_mem_free(pWdaParams);
17193 }
17194 return CONVERT_WDI2VOS_STATUS(status);
17195}
17196
17197/*==========================================================================
17198 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
17199
17200 DESCRIPTION
17201 API to send EXTScan Get Cached Results Request to WDI
17202
17203 PARAMETERS
17204 pWDA: Pointer to WDA context
17205 wdaRequest: Pointer to EXTScan req parameters
17206===========================================================================*/
17207VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
17208 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
17209{
17210 WDI_Status status = WDI_STATUS_SUCCESS;
17211 tWDA_ReqParams *pWdaParams;
17212
17213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17214 "%s: ", __func__);
17215 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17216 if (NULL == pWdaParams)
17217 {
17218 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17219 "%s: VOS MEM Alloc Failure", __func__);
17220 VOS_ASSERT(0);
17221 return VOS_STATUS_E_NOMEM;
17222 }
17223 pWdaParams->pWdaContext = pWDA;
17224 pWdaParams->wdaMsgParam = wdaRequest;
17225 pWdaParams->wdaWdiApiMsgParam = NULL;
17226
17227 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
17228 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
17229 (void *)pWdaParams);
17230 if (IS_WDI_STATUS_FAILURE(status))
17231 {
17232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17233 "Failure to request. Free all the memory " );
17234 vos_mem_free(pWdaParams->wdaMsgParam);
17235 vos_mem_free(pWdaParams);
17236 }
17237 return CONVERT_WDI2VOS_STATUS(status);
17238}
17239
17240/*==========================================================================
17241 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
17242
17243 DESCRIPTION
17244 API to send EXTScan Get Capabilities Request to WDI
17245
17246 PARAMETERS
17247 pWDA: Pointer to WDA context
17248 wdaRequest: Pointer to EXTScan req parameters
17249===========================================================================*/
17250VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
17251 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
17252{
17253 WDI_Status status = WDI_STATUS_SUCCESS;
17254 tWDA_ReqParams *pWdaParams;
17255
17256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17257 "%s:", __func__);
17258 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17259 if (NULL == pWdaParams)
17260 {
17261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17262 "%s: VOS MEM Alloc Failure", __func__);
17263 VOS_ASSERT(0);
17264 return VOS_STATUS_E_NOMEM;
17265 }
17266 pWdaParams->pWdaContext = pWDA;
17267 pWdaParams->wdaMsgParam = wdaRequest;
17268 pWdaParams->wdaWdiApiMsgParam = NULL;
17269
17270 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17271 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17272 (void *)pWdaParams);
17273 if (IS_WDI_STATUS_FAILURE(status))
17274 {
17275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17276 "Failure to request. Free all the memory " );
17277 vos_mem_free(pWdaParams->wdaMsgParam);
17278 vos_mem_free(pWdaParams);
17279 }
17280 return CONVERT_WDI2VOS_STATUS(status);
17281}
17282
17283/*==========================================================================
17284 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17285
17286 DESCRIPTION
17287 API to send Set BSSID Hotlist Request to WDI
17288
17289 PARAMETERS
17290 pWDA: Pointer to WDA context
17291 wdaRequest: Pointer to EXTScan req parameters
17292===========================================================================*/
17293VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17294 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17295{
17296 WDI_Status status = WDI_STATUS_SUCCESS;
17297 tWDA_ReqParams *pWdaParams;
17298
17299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17300 "%s: ", __func__);
17301 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17302 if (NULL == pWdaParams)
17303 {
17304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17305 "%s: VOS MEM Alloc Failure", __func__);
17306 VOS_ASSERT(0);
17307 return VOS_STATUS_E_NOMEM;
17308 }
17309 pWdaParams->pWdaContext = pWDA;
17310 pWdaParams->wdaMsgParam = wdaRequest;
17311 pWdaParams->wdaWdiApiMsgParam = NULL;
17312
17313 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17314 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17315 (void *)pWdaParams);
17316 if (IS_WDI_STATUS_FAILURE(status))
17317 {
17318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17319 "Failure to request. Free all the memory " );
17320 vos_mem_free(pWdaParams->wdaMsgParam);
17321 vos_mem_free(pWdaParams);
17322 }
17323 return CONVERT_WDI2VOS_STATUS(status);
17324}
17325
17326/*==========================================================================
17327 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17328
17329 DESCRIPTION
17330 API to send Reset BSSID Hotlist Request to WDI
17331
17332 PARAMETERS
17333 pWDA: Pointer to WDA context
17334 wdaRequest: Pointer to EXTScan req parameters
17335===========================================================================*/
17336VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17337 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17338{
17339 WDI_Status status = WDI_STATUS_SUCCESS;
17340 tWDA_ReqParams *pWdaParams;
17341
17342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17343 "%s:", __func__);
17344 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17345 if (NULL == pWdaParams)
17346 {
17347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17348 "%s: VOS MEM Alloc Failure", __func__);
17349 VOS_ASSERT(0);
17350 return VOS_STATUS_E_NOMEM;
17351 }
17352 pWdaParams->pWdaContext = pWDA;
17353 pWdaParams->wdaMsgParam = wdaRequest;
17354 pWdaParams->wdaWdiApiMsgParam = NULL;
17355
17356 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17357 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17358 (void *)pWdaParams);
17359 if (IS_WDI_STATUS_FAILURE(status))
17360 {
17361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17362 "Failure to request. Free all the memory " );
17363 vos_mem_free(pWdaParams->wdaMsgParam);
17364 vos_mem_free(pWdaParams);
17365 }
17366 return CONVERT_WDI2VOS_STATUS(status);
17367}
17368
17369/*==========================================================================
17370 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17371
17372 DESCRIPTION
17373 API to send Set Significant RSSI Change Request to WDI
17374
17375 PARAMETERS
17376 pWDA: Pointer to WDA context
17377 wdaRequest: Pointer to EXTScan req parameters
17378===========================================================================*/
17379VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17380 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17381{
17382 WDI_Status status = WDI_STATUS_SUCCESS;
17383 tWDA_ReqParams *pWdaParams;
17384
17385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17386 "%s: ", __func__);
17387 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17388 if (NULL == pWdaParams)
17389 {
17390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17391 "%s: VOS MEM Alloc Failure", __func__);
17392 VOS_ASSERT(0);
17393 return VOS_STATUS_E_NOMEM;
17394 }
17395 pWdaParams->pWdaContext = pWDA;
17396 pWdaParams->wdaMsgParam = wdaRequest;
17397 pWdaParams->wdaWdiApiMsgParam = NULL;
17398
17399 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17400 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17401 (void *)pWdaParams);
17402 if (IS_WDI_STATUS_FAILURE(status))
17403 {
17404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17405 "Failure to request. Free all the memory " );
17406 vos_mem_free(pWdaParams->wdaMsgParam);
17407 vos_mem_free(pWdaParams);
17408 }
17409 return CONVERT_WDI2VOS_STATUS(status);
17410}
17411
17412/*==========================================================================
17413 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17414
17415 DESCRIPTION
17416 API to send Reset Significant RSSI Change Request to WDI
17417
17418 PARAMETERS
17419 pWDA: Pointer to WDA context
17420 wdaRequest: Pointer to EXTScan req parameters
17421===========================================================================*/
17422VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17423 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17424{
17425 WDI_Status status = WDI_STATUS_SUCCESS;
17426 tWDA_ReqParams *pWdaParams;
17427
17428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17429 "%s:", __func__);
17430 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17431 if (NULL == pWdaParams)
17432 {
17433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17434 "%s: VOS MEM Alloc Failure", __func__);
17435 VOS_ASSERT(0);
17436 return VOS_STATUS_E_NOMEM;
17437 }
17438 pWdaParams->pWdaContext = pWDA;
17439 pWdaParams->wdaMsgParam = wdaRequest;
17440 pWdaParams->wdaWdiApiMsgParam = NULL;
17441
17442 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17443 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17444 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17445 (void *)pWdaParams);
17446 if (IS_WDI_STATUS_FAILURE(status))
17447 {
17448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17449 "Failure to request. Free all the memory " );
17450 vos_mem_free(pWdaParams->wdaMsgParam);
17451 vos_mem_free(pWdaParams);
17452 }
17453 return CONVERT_WDI2VOS_STATUS(status);
17454}
17455#endif /* WLAN_FEATURE_EXTSCAN */
17456
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17457#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17458
17459/*==========================================================================
17460 FUNCTION WDA_LLStatsSetRspCallback
17461
17462 DESCRIPTION
17463 API to process set link layer statistics response from FW
17464
17465 PARAMETERS
17466 pRsp: Pointer to set link layer statistics response
17467 pUserData: Pointer to user data
17468
17469 RETURN VALUE
17470 NONE
17471
17472===========================================================================*/
17473void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17474{
17475 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17476
17477
17478 if (NULL == pWdaParams)
17479 {
17480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17481 "%s: pWdaParams received NULL", __func__);
17482 VOS_ASSERT(0) ;
17483 return ;
17484 }
17485
17486 /* Do not need to send notification to upper layer
17487 * Just free allocated resources */
17488 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17489 {
17490 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17491 }
17492 if (pWdaParams->wdaMsgParam != NULL)
17493 {
17494 vos_mem_free(pWdaParams->wdaMsgParam);
17495 }
17496 vos_mem_free(pWdaParams) ;
17497
17498 return;
17499}
17500
17501/*==========================================================================
17502 FUNCTION WDA_ProcessLLStatsSetReq
17503
17504 DESCRIPTION
17505 API to send Set Link Layer Stats request to WDI
17506
17507 PARAMETERS
17508 pWDA: Pointer to WDA context
17509 wdaRequest: Pointer to set Link Layer Stats req parameters
17510===========================================================================*/
17511VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17512 tSirLLStatsSetReq *wdaRequest)
17513{
17514 WDI_Status status = WDI_STATUS_SUCCESS;
17515 tWDA_ReqParams *pWdaParams;
17516
17517 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17518 if (NULL == pWdaParams)
17519 {
17520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17521 "%s: VOS MEM Alloc Failure", __func__);
17522 VOS_ASSERT(0);
17523 return VOS_STATUS_E_NOMEM;
17524 }
17525 pWdaParams->pWdaContext = pWDA;
17526 pWdaParams->wdaMsgParam = wdaRequest;
17527 pWdaParams->wdaWdiApiMsgParam = NULL;
17528
17529 status = WDI_LLStatsSetReq((void *)wdaRequest,
17530 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17531 (void *)pWdaParams);
17532 if (IS_WDI_STATUS_FAILURE(status))
17533 {
17534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17535 "Failure to request. Free all the memory " );
17536 vos_mem_free(pWdaParams->wdaMsgParam);
17537 vos_mem_free(pWdaParams);
17538 }
17539 return CONVERT_WDI2VOS_STATUS(status);
17540}
17541
17542/*==========================================================================
17543 FUNCTION WDA_LLStatsGetRspCallback
17544
17545 DESCRIPTION
17546 API to process get link layer statistics response from FW
17547
17548 PARAMETERS
17549 pRsp: Pointer to get link layer statistics response
17550 pUserData: Pointer to user data
17551
17552 RETURN VALUE
17553 NONE
17554
17555===========================================================================*/
17556void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17557{
17558 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17559
17560 if (NULL == pWdaParams)
17561 {
17562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17563 "%s: pWdaParams received NULL", __func__);
17564 VOS_ASSERT(0) ;
17565 return ;
17566 }
17567
17568 /* Do not need to send notification to upper layer
17569 * Just free allocated resources */
17570 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17571 {
17572 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17573 }
17574 if (pWdaParams->wdaMsgParam != NULL)
17575 {
17576 vos_mem_free(pWdaParams->wdaMsgParam);
17577 }
17578 vos_mem_free(pWdaParams) ;
17579
17580 return;
17581}
17582
17583/*==========================================================================
17584 FUNCTION WDA_ProcessLLStatsGetReq
17585
17586 DESCRIPTION
17587 API to send Get Link Layer Stats request to WDI
17588
17589 PARAMETERS
17590 pWDA: Pointer to WDA context
17591 wdaRequest: Pointer to get Link Layer Stats req parameters
17592===========================================================================*/
17593VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17594 tSirLLStatsGetReq *wdaRequest)
17595{
17596 WDI_Status status = WDI_STATUS_SUCCESS;
17597 tWDA_ReqParams *pWdaParams;
17598
17599 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17600 if (NULL == pWdaParams)
17601 {
17602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17603 "%s: VOS MEM Alloc Failure", __func__);
17604 VOS_ASSERT(0);
17605 return VOS_STATUS_E_NOMEM;
17606 }
17607 pWdaParams->pWdaContext = pWDA;
17608 pWdaParams->wdaMsgParam = wdaRequest;
17609 pWdaParams->wdaWdiApiMsgParam = NULL;
17610
17611 status = WDI_LLStatsGetReq((void *) wdaRequest,
17612 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17613 (void *)pWdaParams);
17614 if (IS_WDI_STATUS_FAILURE(status))
17615 {
17616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17617 "Failure to request. Free all the memory " );
17618 vos_mem_free(pWdaParams->wdaMsgParam);
17619 vos_mem_free(pWdaParams);
17620 }
17621 return CONVERT_WDI2VOS_STATUS(status);
17622}
17623
17624/*==========================================================================
17625 FUNCTION WDA_LLStatsClearRspCallback
17626
17627 DESCRIPTION
17628 API to process clear link layer statistics response from FW
17629
17630 PARAMETERS
17631 pRsp: Pointer to clear link layer statistics response
17632 pUserData: Pointer to user data
17633
17634 RETURN VALUE
17635 NONE
17636
17637===========================================================================*/
17638void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17639{
17640 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17641
17642
17643 if (NULL == pWdaParams)
17644 {
17645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17646 "%s: pWdaParams received NULL", __func__);
17647 VOS_ASSERT(0) ;
17648 return ;
17649 }
17650 /* Do not need to send notification to upper layer
17651 * Just free allocated resources */
17652 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17653 {
17654 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17655 }
17656 if (pWdaParams->wdaMsgParam != NULL)
17657 {
17658 vos_mem_free(pWdaParams->wdaMsgParam);
17659 }
17660 vos_mem_free(pWdaParams) ;
17661 return;
17662}
17663
17664/*==========================================================================
17665 FUNCTION WDA_ProcessLLStatsClearReq
17666
17667 DESCRIPTION
17668 API to send Clear Link Layer Stats request to WDI
17669
17670 PARAMETERS
17671 pWDA: Pointer to WDA context
17672 wdaRequest: Pointer to earLink Layer Stats req
17673===========================================================================*/
17674VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17675 tSirLLStatsClearReq *wdaRequest)
17676{
17677 WDI_Status status = WDI_STATUS_SUCCESS;
17678 tWDA_ReqParams *pWdaParams;
17679
17680 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17681 if (NULL == pWdaParams)
17682 {
17683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17684 "%s: VOS MEM Alloc Failure", __func__);
17685 VOS_ASSERT(0);
17686 return VOS_STATUS_E_NOMEM;
17687 }
17688 pWdaParams->pWdaContext = pWDA;
17689 pWdaParams->wdaMsgParam = wdaRequest;
17690 pWdaParams->wdaWdiApiMsgParam = NULL;
17691
17692 status = WDI_LLStatsClearReq((void *) wdaRequest,
17693 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17694 (void *)pWdaParams);
17695 if (IS_WDI_STATUS_FAILURE(status))
17696 {
17697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17698 "Failure to request. Free all the memory " );
17699 vos_mem_free(pWdaParams->wdaMsgParam);
17700 vos_mem_free(pWdaParams);
17701 }
17702 return CONVERT_WDI2VOS_STATUS(status);
17703}
17704
17705#endif /* WLAN_FEATURE_LINK_LAYER_STATS */