Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 837adf2eb7148fa878e2aca4747a243f4d046e55 / . / CORE / WDA / src / wlan_qct_wda.c
blob: 562229c5257505a8d998f0927cd3639d8bdf3d27 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]2 * Copyright (c) 2012-2015 The Linux Foundation. All rights reserved.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]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===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]41/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]42 EDIT HISTORY FOR FILE
43
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44 This section contains comments describing changes made to the module.
45 Notice that changes are listed in reverse chronological order.
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 $Header$$DateTime$$Author$
48
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]49 when who what, where, why
50---------- --- -------------------------------------------------
5110/05/2011 haparna Adding support for Keep Alive Feature
522010-12-30 smiryala UMAC convergence changes
532010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
54===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]55#include "vos_mq.h"
56#include "vos_api.h"
57#include "vos_packet.h"
58#include "vos_nvitem.h"
59#include "sirApi.h"
60#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]61#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]62#include "wlan_qct_wda.h"
63#include "wlan_qct_wda_msg.h"
64#include "wlan_qct_wdi_cfg.h"
65#include "wlan_qct_wdi.h"
66#include "wlan_qct_wdi_ds.h"
67#include "wlan_hal_cfg.h"
68/**********************/
69#include "wniApi.h"
70#include "cfgApi.h"
71#include "limApi.h"
72#include "wlan_qct_tl.h"
73#include "wlan_qct_tli_ba.h"
74#include "limUtils.h"
75#include "btcApi.h"
76#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]77#include "pttMsgApi.h"
78#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]79/* Used MACRO's */
80/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]81#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
83#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]84#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define CONVERT_WDI2SIR_STATUS(x) \
86 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
87
88#define IS_WDI_STATUS_FAILURE(status) \
89 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]90#define CONVERT_WDI2VOS_STATUS(x) \
91 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
92
93/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]94#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]95#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]96#define WDA_GET_BA_TXFLAG(a, b, c) \
97 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
98
99#define WDA_SET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
101
102#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]104#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
105 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]106/* timer related Macros */
107#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
108 tx_timer_create(a, b, c, d, e, f, g)
109#define WDA_START_TIMER(a) tx_timer_activate(a)
110#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
111#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]112#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]113
114#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
115 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]117#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]118#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]120#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]122#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]123
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]124#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]125#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
126 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
127 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
128
129#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
130#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]131#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
132
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]133/* extern declarations */
134extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]135extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
136
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]137/* forward declarations */
138void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
139 void *pBodyptr, tANI_U32 bodyVal) ;
140VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
141 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]142VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
143VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
144
145extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
146 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]147void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]148void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
149 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
150void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
151 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
152void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
153 void* pUserData ) ;
154static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
155static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
156void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]157void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]158void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]159#ifdef WLAN_FEATURE_VOWIFI_11R
160VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
161#endif /* WLAN_FEATURE_VOWIFI_11R */
162
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]163void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
164void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
165VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166#ifdef FEATURE_WLAN_SCAN_PNO
167static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
168static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
169static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
170#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]171#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]172VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]173void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
174void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
175void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
176#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]177#ifdef WLAN_FEATURE_PACKET_FILTERING
178static VOS_STATUS WDA_Process8023MulticastListReq (
179 tWDA_CbContext *pWDA,
180 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
181 );
182static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
183 tWDA_CbContext *pWDA,
184 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
185 );
186static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
187 tWDA_CbContext *pWDA,
188 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
189 );
190static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
191 tWDA_CbContext *pWDA,
192 tSirRcvFltPktClearParam *pRcvFltPktClearParam
193 );
194#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]195VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]196static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
197 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
199 v_U8_t *pDefaultKeyId,
200 v_U8_t *pNumKeys,
201 WDI_KeysType *pWdiKeys );
202
203#ifdef WLAN_FEATURE_GTK_OFFLOAD
204static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
205static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
206#endif // WLAN_FEATURE_GTK_OFFLOAD
207
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]208v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
209 tSirBcnMissRateReq *pData);
210
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]211VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
212 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]213#ifdef WLAN_FEATURE_11AC
214VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
215 tUpdateVHTOpMode *pData);
216#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]217
218#ifdef FEATURE_WLAN_LPHB
219VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
220 tSirLPHBReq *pData);
221#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]222
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]223#ifdef WLAN_FEATURE_EXTSCAN
224VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
225 tSirEXTScanStartReqParams *wdaRequest);
226VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
227 tSirEXTScanStopReqParams *wdaRequest);
228VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
229 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
230VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
231 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
232VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
233 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
234VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
235 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]236VOS_STATUS WDA_ProcessEXTScanSetSSIDHotlistReq(tWDA_CbContext *pWDA,
237 tSirEXTScanSetSsidHotListReqParams *wdaRequest);
238VOS_STATUS WDA_ProcessEXTScanResetSSIDHotlistReq(tWDA_CbContext *pWDA,
239 tSirEXTScanResetSsidHotlistReqParams *wdaRequest);
240
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]241#endif /* WLAN_FEATURE_EXTSCAN */
242
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]243#ifdef WLAN_FEATURE_LINK_LAYER_STATS
244VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
245 tSirLLStatsSetReq *wdaRequest);
246
247VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
248 tSirLLStatsGetReq *wdaRequest);
249
250VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
251 tSirLLStatsClearReq *wdaRequest);
252#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]253
254v_VOID_t WDA_ProcessFWStatsGetReq(tWDA_CbContext *pWDA,
255 tSirFWStatsGetReq *wdaRequest);
256
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]257VOS_STATUS WDA_ProcessEncryptMsgReq(tWDA_CbContext *pWDA,
258 u8 *wdaRequest);
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]259VOS_STATUS
260WDA_ProcessSetRtsCtsHTVhtInd(tWDA_CbContext *pWDA,
261 tANI_U32 val);
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]262
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]263VOS_STATUS
264WDA_ProcessFwrMemDumpReq(tWDA_CbContext *pWDA,
265 tAniFwrDumpReq* pFwrMemDumpReq);
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]266
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]267VOS_STATUS WDA_ProcessMonStartReq( tWDA_CbContext *pWDA, void* wdaRequest);
268VOS_STATUS WDA_ProcessMonStopReq( tWDA_CbContext *pWDA, void* wdaRequest);
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]269VOS_STATUS WDA_ProcessEnableDisableCAEventInd(tWDA_CbContext *pWDA, tANI_U8 val);
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]270/*
271 * FUNCTION: WDA_ProcessNanRequest
272 * Process NAN request
273 */
274VOS_STATUS WDA_ProcessNanRequest(tWDA_CbContext *pWDA,
275 tNanRequest *wdaRequest)
276{
277 WDI_Status status = WDI_STATUS_SUCCESS;
278 tWDA_ReqParams *pWdaParams;
279 WDI_NanRequestType *wdiRequest = NULL;
280 size_t wdiReqLength = sizeof(WDI_NanRequestType)
281 - sizeof(wdiRequest->request_data)
282 + wdaRequest->request_data_len;
283
284 wdiRequest = (WDI_NanRequestType *)vos_mem_malloc(wdiReqLength);
285
286 if (NULL == wdiRequest)
287 {
288 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
289 "%s: VOS MEM Alloc Failure, size : %zu", __func__,
290 wdiReqLength);
291 vos_mem_free(wdaRequest);
292 return VOS_STATUS_E_NOMEM;
293 }
294
295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
296 "WDA: Process Nan Request length: %zu", wdiReqLength);
297
298 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
299 if (NULL == pWdaParams)
300 {
301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
302 "%s: VOS MEM Alloc Failure for tWDA_ReqParams", __func__);
303 VOS_ASSERT(0);
304 vos_mem_free(wdaRequest);
305 vos_mem_free(wdiRequest);
306 return VOS_STATUS_E_NOMEM;
307 }
308
309 wdiRequest->request_data_len = wdaRequest->request_data_len;
310
311 vos_mem_copy( wdiRequest->request_data,
312 wdaRequest->request_data,
313 wdaRequest->request_data_len);
314
315 vos_mem_free(wdaRequest);
316
317 pWdaParams->pWdaContext = pWDA;
318 pWdaParams->wdaMsgParam = NULL;
319 pWdaParams->wdaWdiApiMsgParam = wdiRequest;
320
321 status = WDI_NanRequest(wdiRequest, pWdaParams);
322
323 if (IS_WDI_STATUS_FAILURE(status))
324 {
325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
326 "Failure to request. Free all the memory " );
327 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
328 vos_mem_free(pWdaParams);
329 }
330
331 return CONVERT_WDI2VOS_STATUS(status) ;
332}
333
334
335
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336/*
337 * FUNCTION: WDA_open
338 * Allocate the WDA context
339 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]340VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]341 tMacOpenParameters *pMacParams )
342{
343 tWDA_CbContext *wdaContext;
344 VOS_STATUS status;
345 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /* Allocate WDA context */
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]347 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]348 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
349 if(!VOS_IS_STATUS_SUCCESS(status))
350 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]351 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "%s: Failed to "
352 "allocate context for WDA - status = %d",__func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]353 return VOS_STATUS_E_NOMEM;
354 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]355 /*__asm int 3;*/
356 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
357
358 /* Initialize data structures */
359 wdaContext->pVosContext = pVosContext;
360 wdaContext->wdaState = WDA_INIT_STATE;
361 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
362
363 /* Initialize WDA-WDI synchronization event */
364 status = vos_event_init(&wdaContext->wdaWdiEvent);
365 if(!VOS_IS_STATUS_SUCCESS(status))
366 {
367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]368 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]369 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]371 /* Init Frame transfer event */
372 status = vos_event_init(&wdaContext->txFrameEvent);
373 if(!VOS_IS_STATUS_SUCCESS(status))
374 {
375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]376 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]377 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]378 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]379 status = vos_event_init(&wdaContext->suspendDataTxEvent);
380 if(!VOS_IS_STATUS_SUCCESS(status))
381 {
382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]383 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]384 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]385 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]386 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
387 if(!VOS_IS_STATUS_SUCCESS(status))
388 {
389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]390 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]391 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]393 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]394 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]395 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]396 &wdiDevCapability, pMacParams->driverType))
397 {
398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
399 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]400 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]401 }
402 else
403 {
404 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
405 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
406 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]407 /* update max STA in WDA used for BA */
408 wdaContext->wdaMaxSta = pMacParams->maxStation;
409 /* store the frameTransRequired flag in wdaContext, to send this to HAL
410 * in WDA_Start
411 */
412 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
413 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]414 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]415
416error:
417 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
418 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]419}
420
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421/*
422 * FUNCTION: WDA_preStart
423 * Trigger DAL-AL to start CFG download
424 */
425VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
426{
427 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
428 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429 /*
430 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
431 */
432 wdaMsg.type = WNI_CFG_DNLD_REQ ;
433 wdaMsg.bodyptr = NULL;
434 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 /* post the message.. */
436 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
437 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
438 {
439 vosStatus = VOS_STATUS_E_BADMSG;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 return( vosStatus );
442}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]443/*
444 * FUNCTION: WDA_wdiStartCallback
445 * Once WDI_Start is finished, WDI start callback will be called by WDI
446 * to indicate completion of WDI_Start.
447 */
448void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
449 void *pVosContext)
450{
451 tWDA_CbContext *wdaContext;
452 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]453 if (NULL == pVosContext)
454 {
455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]456 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]457 return;
458 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]459 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
460 if (NULL == wdaContext)
461 {
462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]463 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]464 return;
465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]466 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
467 {
468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]469 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]470 }
471 else
472 {
473 wdaContext->wdaState = WDA_START_STATE;
474 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]475 /* extract and save version information from the Start Response */
476 wdaContext->wcnssWlanCompiledVersion.major =
477 wdiRspParams->wlanCompiledVersion.major;
478 wdaContext->wcnssWlanCompiledVersion.minor =
479 wdiRspParams->wlanCompiledVersion.minor;
480 wdaContext->wcnssWlanCompiledVersion.version =
481 wdiRspParams->wlanCompiledVersion.version;
482 wdaContext->wcnssWlanCompiledVersion.revision =
483 wdiRspParams->wlanCompiledVersion.revision;
484 wdaContext->wcnssWlanReportedVersion.major =
485 wdiRspParams->wlanReportedVersion.major;
486 wdaContext->wcnssWlanReportedVersion.minor =
487 wdiRspParams->wlanReportedVersion.minor;
488 wdaContext->wcnssWlanReportedVersion.version =
489 wdiRspParams->wlanReportedVersion.version;
490 wdaContext->wcnssWlanReportedVersion.revision =
491 wdiRspParams->wlanReportedVersion.revision;
492 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
493 wdiRspParams->wcnssSoftwareVersion,
494 sizeof(wdaContext->wcnssSoftwareVersionString));
495 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
496 wdiRspParams->wcnssHardwareVersion,
497 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 /* Notify WDA_start that WDI_Start has completed */
499 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]500 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]501 {
502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]505 return;
506}
507
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508/*
509 * FUNCTION: WDA_start
510 * Prepare TLV configuration and call WDI_Start.
511 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]512VOS_STATUS WDA_start(v_PVOID_t pVosContext)
513{
514 tWDA_CbContext *wdaContext;
515 VOS_STATUS status;
516 WDI_Status wdiStatus;
517 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 if (NULL == pVosContext)
519 {
520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]521 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]522 return VOS_STATUS_E_FAILURE;
523 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]524 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
525 if (NULL == wdaContext)
526 {
527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]528 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]529 return VOS_STATUS_E_FAILURE;
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 /* Non-FTM mode, WDA status for START must be INIT
532 * FTM mode, WDA Status for START can be INIT or STOP */
533 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
534 (WDA_STOP_STATE != wdaContext->wdaState) )
535 {
536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
537 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]538 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]539 return VOS_STATUS_E_FAILURE;
540 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]541 /* initialize the wdiStartParam. Note that we can create this on
542 the stack since we won't exit until WDI_Start() completes or
543 times out */
544 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]545 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]546 /* prepare the config TLV for the WDI */
547 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
548 if ( !VOS_IS_STATUS_SUCCESS(status) )
549 {
550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]551 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]552 return VOS_STATUS_E_FAILURE;
553 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]554 /* note from here onwards if an error occurs we must
555 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]556 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
557 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
558 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]559 /* initialize the WDA-WDI synchronization event */
560 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]561 /* call WDI start */
562 wdiStatus = WDI_Start(&wdiStartParam,
563 (WDI_StartRspCb)WDA_wdiStartCallback,
564 (v_VOID_t *)pVosContext);
565 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
566 {
567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]568 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]569 vos_mem_free(wdiStartParam.pConfigBuffer);
570 return VOS_STATUS_E_FAILURE;
571 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]572 /* wait for WDI start to invoke our callback */
573 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
574 WDA_WDI_START_TIMEOUT );
575 if ( !VOS_IS_STATUS_SUCCESS(status) )
576 {
577 if ( VOS_STATUS_E_TIMEOUT == status )
578 {
579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]580 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 }
582 else
583 {
584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
585 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]586 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]587 }
588 vos_mem_free(wdiStartParam.pConfigBuffer);
Siddharth Bhalbea38ad2014-10-12 14:10:52 +0530[diff] [blame]589 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]590 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]591 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]592 /* we no longer need the config TLV */
593 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]594 /* if we are not in the START state then WDI_Start() failed */
595 if (WDA_START_STATE != wdaContext->wdaState)
596 {
597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]598 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]599 return VOS_STATUS_E_FAILURE;
600 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]601 /* FTM mode does not need to monitor BA activity */
602 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
603 {
604 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]605 if(VOS_STATUS_SUCCESS == status)
606 {
607 wdaContext->wdaTimersCreated = VOS_TRUE;
608 }
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]609 else
610 {
611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
612 FL("wda create timers failed"));
613 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]614 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]615 else
616 {
617 vos_event_init(&wdaContext->ftmStopDoneEvent);
618 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]619 return status;
620}
621
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622/*
623 * FUNCTION: WDA_prepareConfigTLV
624 * Function to prepare CFG for DAL(WDA)
625 */
626VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
627 WDI_StartReqParamsType *wdiStartParams )
628{
629 /* get pMac to acess CFG data base */
630 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
631 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
632 tHalCfg *tlvStruct = NULL ;
633 tANI_U8 *tlvStructStart = NULL ;
634 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
635 v_PVOID_t *configParam;
636 tANI_U32 configParamSize;
637 tANI_U32 *configDataValue;
638 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]639 tANI_U8 i;
640
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]641 if ((NULL == pMac)||(NULL == wdaContext))
642 {
643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]644 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]645 VOS_ASSERT(0);
646 return VOS_STATUS_E_FAILURE;
647 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]648 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
649 WNI_CFG_STA_ID_LEN +
650 WNI_CFG_EDCA_WME_ACBK_LEN +
651 WNI_CFG_EDCA_WME_ACBE_LEN +
652 WNI_CFG_EDCA_WME_ACVI_LEN +
653 WNI_CFG_EDCA_WME_ACVO_LEN +
654 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]655 /* malloc memory for all configs in one shot */
656 configParam = vos_mem_malloc(configParamSize);
657
658 if(NULL == configParam )
659 {
660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]661 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 VOS_ASSERT(0) ;
663 return VOS_STATUS_E_NOMEM;
664 }
665 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]666 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]667 tlvStruct = (tHalCfg *)configParam;
668 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]669 /* TODO: Remove Later */
670 /* QWLAN_HAL_CFG_STA_ID */
671 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
672 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
673 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
674 eSIR_SUCCESS)
675 {
676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
677 "Failed to get value for WNI_CFG_STA_ID");
678 goto handle_failure;
679 }
680 tlvStruct->length = strLength ;
681 /* calculate the pad bytes to have the CFG in aligned format */
682 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
683 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]684 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
685 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]686 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
687 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
688 tlvStruct->length = sizeof(tANI_U32);
689 configDataValue = (tANI_U32 *)(tlvStruct + 1);
690 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
691 != eSIR_SUCCESS)
692 {
693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
694 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
695 goto handle_failure;
696 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]697 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
698 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]699 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
700 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
701 tlvStruct->length = sizeof(tANI_U32);
702 configDataValue = (tANI_U32 *)(tlvStruct + 1);
703 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
704 eSIR_SUCCESS)
705 {
706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
707 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
708 goto handle_failure;
709 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]710 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
711 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]712 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
713 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
714 tlvStruct->length = sizeof(tANI_U32);
715 configDataValue = (tANI_U32 *)(tlvStruct + 1);
716 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
717 != eSIR_SUCCESS)
718 {
719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
720 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
721 goto handle_failure;
722 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]723 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
724 + sizeof(tHalCfg) + tlvStruct->length)) ;
725
726 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
727 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
728 tlvStruct->length = sizeof(tANI_U32);
729 configDataValue = (tANI_U32 *)(tlvStruct + 1);
730 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
731 configDataValue ) != eSIR_SUCCESS)
732 {
733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
734 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
735 goto handle_failure;
736 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]737 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
738 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]739 /* QWLAN_HAL_CFG_CAL_PERIOD */
740 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
741 tlvStruct->length = sizeof(tANI_U32);
742 configDataValue = (tANI_U32 *)(tlvStruct + 1);
743 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
744 != eSIR_SUCCESS)
745 {
746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
747 "Failed to get value for WNI_CFG_CAL_PERIOD");
748 goto handle_failure;
749 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]750 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
751 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]752 /* QWLAN_HAL_CFG_CAL_CONTROL */
753 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
754 tlvStruct->length = sizeof(tANI_U32);
755 configDataValue = (tANI_U32 *)(tlvStruct + 1);
756 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
757 != eSIR_SUCCESS)
758 {
759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
760 "Failed to get value for WNI_CFG_CAL_CONTROL");
761 goto handle_failure;
762 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]763 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
764 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]765 /* QWLAN_HAL_CFG_PROXIMITY */
766 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
767 tlvStruct->length = sizeof(tANI_U32);
768 configDataValue = (tANI_U32 *)(tlvStruct + 1);
769 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
770 != eSIR_SUCCESS)
771 {
772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
773 "Failed to get value for WNI_CFG_PROXIMITY");
774 goto handle_failure;
775 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]776 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
777 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]778 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
779 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
780 tlvStruct->length = sizeof(tANI_U32);
781 configDataValue = (tANI_U32 *)(tlvStruct + 1);
782 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
783 != eSIR_SUCCESS)
784 {
785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
786 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
787 goto handle_failure;
788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]789 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
790 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]791 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
792 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
793 tlvStruct->length = sizeof(tANI_U32);
794 configDataValue = (tANI_U32 *)(tlvStruct + 1);
795 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
796 eSIR_SUCCESS)
797 {
798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
799 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
800 goto handle_failure;
801 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]802 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
803 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]804 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
805 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
806 tlvStruct->length = sizeof(tANI_U32);
807 configDataValue = (tANI_U32 *)(tlvStruct + 1);
808 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
809 configDataValue ) != eSIR_SUCCESS)
810 {
811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
812 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
813 goto handle_failure;
814 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]815 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
816 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]817 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
818 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
819 tlvStruct->length = sizeof(tANI_U32);
820 configDataValue = (tANI_U32 *)(tlvStruct + 1);
821 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
822 eSIR_SUCCESS)
823 {
824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
825 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
826 goto handle_failure;
827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]828 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
829 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]830 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
831 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
832 tlvStruct->length = sizeof(tANI_U32);
833 configDataValue = (tANI_U32 *)(tlvStruct + 1);
834 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
835 eSIR_SUCCESS)
836 {
837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
838 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
839 goto handle_failure;
840 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]841 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
842 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]843 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
844 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
845 tlvStruct->length = sizeof(tANI_U32);
846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
847 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
848 eSIR_SUCCESS)
849 {
850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
851 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
852 goto handle_failure;
853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]854 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
855 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]856 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
857 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
858 tlvStruct->length = sizeof(tANI_U32);
859 configDataValue = (tANI_U32 *)(tlvStruct + 1);
860 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
861 configDataValue ) != eSIR_SUCCESS)
862 {
863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
864 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
865 goto handle_failure;
866 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]867 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
868 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]869 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
870 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
871 tlvStruct->length = sizeof(tANI_U32);
872 configDataValue = (tANI_U32 *)(tlvStruct + 1);
873 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
874 configDataValue ) != eSIR_SUCCESS)
875 {
876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
877 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
878 goto handle_failure;
879 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]880 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
881 + sizeof(tHalCfg) + tlvStruct->length));
882
883 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
884 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
885 tlvStruct->length = sizeof(tANI_U32);
886 configDataValue = (tANI_U32 *)(tlvStruct + 1);
887 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
888 configDataValue ) != eSIR_SUCCESS)
889 {
890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
891 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
892 goto handle_failure;
893 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]894 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
895 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]896 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
897 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
898 tlvStruct->length = sizeof(tANI_U32);
899 configDataValue = (tANI_U32 *)(tlvStruct + 1);
900 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
901 configDataValue ) != eSIR_SUCCESS)
902 {
903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
904 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
905 goto handle_failure;
906 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]907 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
908 + sizeof(tHalCfg) + tlvStruct->length));
909
910 /* QWLAN_HAL_CFG_FIXED_RATE */
911 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
912 tlvStruct->length = sizeof(tANI_U32);
913 configDataValue = (tANI_U32 *)(tlvStruct + 1);
914 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
915 != eSIR_SUCCESS)
916 {
917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
918 "Failed to get value for WNI_CFG_FIXED_RATE");
919 goto handle_failure;
920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]921 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
922 + sizeof(tHalCfg) + tlvStruct->length));
923
924 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
925 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
926 tlvStruct->length = sizeof(tANI_U32);
927 configDataValue = (tANI_U32 *)(tlvStruct + 1);
928 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
929 != eSIR_SUCCESS)
930 {
931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
932 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
933 goto handle_failure;
934 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]935 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
936 + sizeof(tHalCfg) + tlvStruct->length));
937
938 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
939 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
940 tlvStruct->length = sizeof(tANI_U32);
941 configDataValue = (tANI_U32 *)(tlvStruct + 1);
942 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
943 configDataValue ) != eSIR_SUCCESS)
944 {
945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
946 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
947 goto handle_failure;
948 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]949 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
950 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]951 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
952 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
953 tlvStruct->length = sizeof(tANI_U32);
954 configDataValue = (tANI_U32 *)(tlvStruct + 1);
955 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
956 configDataValue ) != eSIR_SUCCESS)
957 {
958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
959 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
960 goto handle_failure;
961 }
962 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
963 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]964 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
965 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
966 tlvStruct->length = sizeof(tANI_U32);
967 configDataValue = (tANI_U32 *)(tlvStruct + 1);
968 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
969 configDataValue ) != eSIR_SUCCESS)
970 {
971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
972 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
973 goto handle_failure;
974 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]975 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
976 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]977 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
978 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
979 tlvStruct->length = sizeof(tANI_U32);
980 configDataValue = (tANI_U32 *)(tlvStruct + 1);
981 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
982 configDataValue ) != eSIR_SUCCESS)
983 {
984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
985 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
986 goto handle_failure;
987 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]988 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
989 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]990 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
991 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
992 tlvStruct->length = sizeof(tANI_U32);
993 configDataValue = (tANI_U32 *)(tlvStruct + 1);
994 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
995 configDataValue ) != eSIR_SUCCESS)
996 {
997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
998 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
999 goto handle_failure;
1000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1001 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1002 + sizeof(tHalCfg) + tlvStruct->length);
1003
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1004 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
1005 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
1006 tlvStruct->length = sizeof(tANI_U32);
1007 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1008 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
1009 configDataValue ) != eSIR_SUCCESS)
1010 {
1011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1012 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
1013 goto handle_failure;
1014 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1015 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1016 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1017 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
1018 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
1019 tlvStruct->length = sizeof(tANI_U32);
1020 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1021 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
1022 configDataValue ) != eSIR_SUCCESS)
1023 {
1024 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1025 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
1026 goto handle_failure;
1027 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1028 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1029 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1030 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
1031 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
1032 tlvStruct->length = sizeof(tANI_U32);
1033 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1034 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
1035 eSIR_SUCCESS)
1036 {
1037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1038 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
1039 goto handle_failure;
1040 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length);
1043
1044 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
1045 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
1046 tlvStruct->length = sizeof(tANI_U32);
1047 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1048 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
1049 configDataValue ) != eSIR_SUCCESS)
1050 {
1051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1052 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
1053 goto handle_failure;
1054 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1055 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1056 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1057 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
1058 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
1059 tlvStruct->length = sizeof(tANI_U32);
1060 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1061 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
1062 configDataValue ) != eSIR_SUCCESS)
1063 {
1064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1065 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
1066 goto handle_failure;
1067 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1068 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1069 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1070 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
1071 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
1072 tlvStruct->length = sizeof(tANI_U32);
1073 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1074 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
1075 configDataValue ) != eSIR_SUCCESS)
1076 {
1077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1078 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
1079 goto handle_failure;
1080 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1081 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1082 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1083 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
1084 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
1085 tlvStruct->length = sizeof(tANI_U32);
1086 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1087 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1088 configDataValue ) != eSIR_SUCCESS)
1089 {
1090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1091 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1092 goto handle_failure;
1093 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1094 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1095 + sizeof(tHalCfg) + tlvStruct->length);
1096
1097 /* QWLAN_HAL_CFG_STATS_PERIOD */
1098 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1099 tlvStruct->length = sizeof(tANI_U32);
1100 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1101 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1102 eSIR_SUCCESS)
1103 {
1104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1105 "Failed to get value for WNI_CFG_STATS_PERIOD");
1106 goto handle_failure;
1107 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1108 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1109 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1110 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1111 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1112 tlvStruct->length = sizeof(tANI_U32);
1113 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1114 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1115 eSIR_SUCCESS)
1116 {
1117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1118 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1119 goto handle_failure;
1120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1121 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1122 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1123 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1124 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1125 tlvStruct->length = sizeof(tANI_U32);
1126 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1127 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1128 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1129 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1130 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1131 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1132 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1133 tlvStruct->length = sizeof(tANI_U32);
1134 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1135 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1136 != eSIR_SUCCESS)
1137 {
1138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1139 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1140 goto handle_failure;
1141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1142 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1143 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1144 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1145 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1146 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1147 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1148 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1149 &strLength) != eSIR_SUCCESS)
1150 {
1151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1152 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1153 goto handle_failure;
1154 }
1155 tlvStruct->length = strLength;
1156 /* calculate the pad bytes to have the CFG in aligned format */
1157 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1158 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1159 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1160 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1162 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1163 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1164 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1165 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1166 &strLength) != eSIR_SUCCESS)
1167 {
1168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1169 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1170 goto handle_failure;
1171 }
1172 tlvStruct->length = strLength;
1173 /* calculate the pad bytes to have the CFG in aligned format */
1174 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1175 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1177 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1178 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1179 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1180 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1181 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1182 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1183 &strLength) != eSIR_SUCCESS)
1184 {
1185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1186 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1187 goto handle_failure;
1188 }
1189 tlvStruct->length = strLength;
1190 /* calculate the pad bytes to have the CFG in aligned format */
1191 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1192 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1193 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1194 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1195 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1196 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1197 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1198 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1199 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1200 &strLength) != eSIR_SUCCESS)
1201 {
1202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1203 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1204 goto handle_failure;
1205 }
1206 tlvStruct->length = strLength;
1207 /* calculate the pad bytes to have the CFG in aligned format */
1208 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1209 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1210 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1211 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1212 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1213 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1214 tlvStruct->length = sizeof(tANI_U32);
1215 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1216 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1217 != eSIR_SUCCESS)
1218 {
1219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1220 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1221 goto handle_failure;
1222 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1223 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1224 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1225 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1226 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1227 tlvStruct->length = sizeof(tANI_U32);
1228 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1229 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1230 != eSIR_SUCCESS)
1231 {
1232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1233 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1234 goto handle_failure;
1235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1236 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1237 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1238 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1239 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1240 tlvStruct->length = sizeof(tANI_U32);
1241 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1242 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1243 != eSIR_SUCCESS)
1244 {
1245 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1246 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1247 goto handle_failure;
1248 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1249 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1250 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1251 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1252 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1253 tlvStruct->length = sizeof(tANI_U32);
1254 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1255 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1256 != eSIR_SUCCESS)
1257 {
1258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1259 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1260 goto handle_failure;
1261 }
1262 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1263 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1264 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1265 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1266 tlvStruct->length = sizeof(tANI_U32);
1267 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1268 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1269 != eSIR_SUCCESS)
1270 {
1271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1272 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1273 goto handle_failure;
1274 }
1275 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1276 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1277 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1278 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1279 tlvStruct->length = sizeof(tANI_U32);
1280 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1281 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1282 != eSIR_SUCCESS)
1283 {
1284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1285 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1286 goto handle_failure;
1287 }
1288 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1289 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1290 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1291 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1292 tlvStruct->length = sizeof(tANI_U32);
1293 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1294 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1295 != eSIR_SUCCESS)
1296 {
1297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1298 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1299 goto handle_failure;
1300 }
1301 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1302 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1303 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1304 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1305 tlvStruct->length = sizeof(tANI_U32);
1306 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1307 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1308 != eSIR_SUCCESS)
1309 {
1310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1311 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1312 goto handle_failure;
1313 }
1314 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1315 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1316 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1317 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1321 != eSIR_SUCCESS)
1322 {
1323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1324 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1325 goto handle_failure;
1326 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1327 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1328 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1329 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1330 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1331 tlvStruct->length = sizeof(tANI_U32);
1332 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1333 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1334 != eSIR_SUCCESS)
1335 {
1336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1337 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1338 goto handle_failure;
1339 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1340 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1341 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1342 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1343 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1344 tlvStruct->length = sizeof(tANI_U32);
1345 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1346 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1347 != eSIR_SUCCESS)
1348 {
1349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1350 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1351 goto handle_failure;
1352 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1355 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1356 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1357 * into FW, so the parameters are added here.
1358 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1359 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1360 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1361 tlvStruct->length = sizeof(tANI_U32);
1362 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1363 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1364 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1365 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1366 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1367 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1368 tlvStruct->length = sizeof(tANI_U32);
1369 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1370 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1371 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1372 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1373 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1374 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1375 tlvStruct->length = sizeof(tANI_U32);
1376 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1377 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1378 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1379 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1380 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
1396 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1397 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1398 tlvStruct->length = sizeof(tANI_U32);
1399 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1400 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1401 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1402 + sizeof(tHalCfg) + tlvStruct->length) ;
1403
1404 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1405 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1406 tlvStruct->length = sizeof(tANI_U32);
1407 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1408 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1409 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1410 + sizeof(tHalCfg) + tlvStruct->length) ;
1411
1412 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1413 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1414 tlvStruct->length = sizeof(tANI_U32);
1415 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1416 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1417 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1418 + sizeof(tHalCfg) + tlvStruct->length) ;
1419
1420 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1421 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1422 tlvStruct->length = sizeof(tANI_U32);
1423 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1424 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1425 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1426 + sizeof(tHalCfg) + tlvStruct->length) ;
1427
1428 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1429 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1430 tlvStruct->length = sizeof(tANI_U32);
1431 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1432 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1433 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1434 + sizeof(tHalCfg) + tlvStruct->length) ;
1435
1436 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1437 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1438 tlvStruct->length = sizeof(tANI_U32);
1439 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1440 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1441 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1442 + sizeof(tHalCfg) + tlvStruct->length) ;
1443
1444 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1445 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1446 tlvStruct->length = sizeof(tANI_U32);
1447 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1448 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1449 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1450 + sizeof(tHalCfg) + tlvStruct->length) ;
1451
1452 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1453 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1454 tlvStruct->length = sizeof(tANI_U32);
1455 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1456 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1457 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1458 + sizeof(tHalCfg) + tlvStruct->length) ;
1459
1460 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1461 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1462 tlvStruct->length = sizeof(tANI_U32);
1463 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1464 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1465 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1466 + sizeof(tHalCfg) + tlvStruct->length) ;
1467
1468 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1469 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1470 tlvStruct->length = sizeof(tANI_U32);
1471 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1472 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1473 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1474 + sizeof(tHalCfg) + tlvStruct->length) ;
1475
1476 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1477 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1478 tlvStruct->length = sizeof(tANI_U32);
1479 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1480 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1481 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1482 + sizeof(tHalCfg) + tlvStruct->length) ;
1483
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1484 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1485 {
1486 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1487 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1488 tlvStruct->length = sizeof(tANI_U32);
1489 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1490 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1491 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1492 + sizeof(tHalCfg) + tlvStruct->length) ;
1493
1494 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1495 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1496 tlvStruct->length = sizeof(tANI_U32);
1497 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1498 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1499 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1500 + sizeof(tHalCfg) + tlvStruct->length) ;
1501
1502 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1503 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1504 tlvStruct->length = sizeof(tANI_U32);
1505 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1506 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1507 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1508 + sizeof(tHalCfg) + tlvStruct->length) ;
1509
1510 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1511 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1512 tlvStruct->length = sizeof(tANI_U32);
1513 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1514 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1515 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1516 + sizeof(tHalCfg) + tlvStruct->length) ;
1517 }
1518
1519 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1520 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1521 tlvStruct->length = sizeof(tANI_U32);
1522 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1523 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1524 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1525 + sizeof(tHalCfg) + tlvStruct->length) ;
1526
1527 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1528 {
1529 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1530 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1531 tlvStruct->length = sizeof(tANI_U32);
1532 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1533 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1534 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1535 + sizeof(tHalCfg) + tlvStruct->length) ;
1536 }
1537
1538 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1539 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1540 tlvStruct->length = sizeof(tANI_U32);
1541 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1542 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1543 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1544 + sizeof(tHalCfg) + tlvStruct->length) ;
1545
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1546 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1547 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1548 tlvStruct->length = sizeof(tANI_U32);
1549 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1550 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1551 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1552 wcnssCompiledApiVersion.minor,
1553 wcnssCompiledApiVersion.version,
1554 wcnssCompiledApiVersion.revision);
1555 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1556 + sizeof(tHalCfg) + tlvStruct->length) ;
1557
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1558 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1559 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1560 tlvStruct->length = sizeof(tANI_U32);
1561 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1562 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1563 configDataValue ) != eSIR_SUCCESS)
1564 {
1565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1566 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1567 goto handle_failure;
1568 }
1569
1570 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1571 + sizeof(tHalCfg) + tlvStruct->length) ;
1572 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1573 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1574 tlvStruct->length = sizeof(tANI_U32);
1575 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1576 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1577 configDataValue ) != eSIR_SUCCESS)
1578 {
1579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1580 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1581 goto handle_failure;
1582 }
1583
1584 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1585 + sizeof(tHalCfg) + tlvStruct->length) ;
1586
1587 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1588 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1589 tlvStruct->length = sizeof(tANI_U32);
1590 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1591 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1592 != eSIR_SUCCESS)
1593 {
1594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1595 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1596 goto handle_failure;
1597 }
1598
1599 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1600 + sizeof(tHalCfg) + tlvStruct->length) ;
1601
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1602 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1603 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1607 != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1611 goto handle_failure;
1612 }
1613
1614 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1615 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1616#ifdef WLAN_SOFTAP_VSTA_FEATURE
1617 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1618 tlvStruct->length = sizeof(tANI_U32);
1619 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1620 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1621 != eSIR_SUCCESS)
1622 {
1623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1624 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1625 goto handle_failure;
1626 }
1627
1628 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1629 + sizeof(tHalCfg) + tlvStruct->length) ;
1630#endif
1631
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1632 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1633 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1634 tlvStruct->length = sizeof(tANI_U32);
1635 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1636
1637 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1638 != eSIR_SUCCESS)
1639 {
1640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1641 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1642 goto handle_failure;
1643 }
1644
1645 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1646 + sizeof(tHalCfg) + tlvStruct->length) ;
1647
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1648/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1649 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1650 tlvStruct->length = sizeof(tANI_U32);
1651 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1652 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1653 configDataValue ) != eSIR_SUCCESS)
1654 {
1655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1656 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1657 goto handle_failure;
1658 }
1659
1660 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1661 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1662#ifdef FEATURE_WLAN_TDLS
1663 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1664 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1665 tlvStruct->length = sizeof(tANI_U32);
1666 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1667 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1668 configDataValue ) != eSIR_SUCCESS)
1669 {
1670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1671 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1672 goto handle_failure;
1673 }
1674 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1675 + sizeof(tHalCfg) + tlvStruct->length) ;
1676
1677 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1678 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1679 tlvStruct->length = sizeof(tANI_U32);
1680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1681 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1682 configDataValue ) != eSIR_SUCCESS)
1683 {
1684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1685 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1686 goto handle_failure;
1687 }
1688 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1689 + sizeof(tHalCfg) + tlvStruct->length) ;
1690 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1691 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1692 tlvStruct->length = sizeof(tANI_U32);
1693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1694 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1695 configDataValue ) != eSIR_SUCCESS)
1696 {
1697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1698 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1699 goto handle_failure;
1700 }
1701 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1702 + sizeof(tHalCfg) + tlvStruct->length) ;
1703 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1704 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1705 tlvStruct->length = sizeof(tANI_U32);
1706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1707 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1708 configDataValue ) != eSIR_SUCCESS)
1709 {
1710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1711 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1712 goto handle_failure;
1713 }
1714 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1715 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1717 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1730#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1731
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1732 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1733 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1734 tlvStruct->length = sizeof(tANI_U32);
1735 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1736 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1737 configDataValue ) != eSIR_SUCCESS)
1738 {
1739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1740 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1741 goto handle_failure;
1742 }
1743
1744 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1745 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1746
1747 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1748 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1749 tlvStruct->length = sizeof(tANI_U32);
1750 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1751 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1752 != eSIR_SUCCESS)
1753 {
1754 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1755 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1756 goto handle_failure;
1757 }
1758 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1759 + sizeof(tHalCfg) + tlvStruct->length));
1760
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1761 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1762 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1763 tlvStruct->length = sizeof(tANI_U32);
1764 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1765 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1766 configDataValue ) != eSIR_SUCCESS)
1767 {
1768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1769 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1770 goto handle_failure;
1771 }
1772
1773 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1774 + sizeof(tHalCfg) + tlvStruct->length) ;
1775
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1776 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1777 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1778 tlvStruct->length = sizeof(tANI_U32);
1779 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1780 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1781 configDataValue ) != eSIR_SUCCESS)
1782 {
1783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1784 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1785 goto handle_failure;
1786 }
1787 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1788 + sizeof(tHalCfg) + tlvStruct->length) ;
1789
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1790 /* QWLAN_HAL_CFG_ATH_DISABLE */
1791 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1792 tlvStruct->length = sizeof(tANI_U32);
1793 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1794 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1795 configDataValue ) != eSIR_SUCCESS)
1796 {
1797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1798 "Failed to get value for WNI_CFG_ATH_DISABLE");
1799 goto handle_failure;
1800 }
1801 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1802 + sizeof(tHalCfg) + tlvStruct->length) ;
1803
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1804 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1805 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1806 tlvStruct->length = sizeof(tANI_U32);
1807 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1808 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1809 configDataValue ) != eSIR_SUCCESS)
1810 {
1811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1812 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1813 goto handle_failure;
1814 }
1815 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1816 + sizeof(tHalCfg) + tlvStruct->length) ;
1817
1818 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1819 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1820 tlvStruct->length = sizeof(tANI_U32);
1821 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1822 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1823 configDataValue ) != eSIR_SUCCESS)
1824 {
1825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1826 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1827 goto handle_failure;
1828 }
1829 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1830 + sizeof(tHalCfg) + tlvStruct->length) ;
1831
1832 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1833 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1834 tlvStruct->length = sizeof(tANI_U32);
1835 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1836 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1837 configDataValue ) != eSIR_SUCCESS)
1838 {
1839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1840 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1841 goto handle_failure;
1842 }
1843 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1844 + sizeof(tHalCfg) + tlvStruct->length) ;
1845
1846 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1847 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1848 tlvStruct->length = sizeof(tANI_U32);
1849 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1850 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1851 configDataValue ) != eSIR_SUCCESS)
1852 {
1853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1854 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1855 goto handle_failure;
1856 }
1857 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1858 + sizeof(tHalCfg) + tlvStruct->length) ;
1859
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1860 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1861 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1862 tlvStruct->length = sizeof(tANI_U32);
1863 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1864 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1865 configDataValue ) != eSIR_SUCCESS)
1866 {
1867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1868 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1869 goto handle_failure;
1870 }
1871 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1872 + sizeof(tHalCfg) + tlvStruct->length) ;
1873
1874 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1875 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1876 tlvStruct->length = sizeof(tANI_U32);
1877 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1878 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1893 configDataValue ) != eSIR_SUCCESS)
1894 {
1895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1896 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1897 goto handle_failure;
1898 }
1899 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1900 + sizeof(tHalCfg) + tlvStruct->length) ;
1901
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1902 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1903 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1904 tlvStruct->length = sizeof(tANI_U32);
1905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1906 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1907 configDataValue ) != eSIR_SUCCESS)
1908 {
1909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1910 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1911 goto handle_failure;
1912 }
1913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1914 + sizeof(tHalCfg) + tlvStruct->length) ;
1915
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1916 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1917 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1918 tlvStruct->length = sizeof(tANI_U32);
1919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1920
1921 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1922 configDataValue ) != eSIR_SUCCESS)
1923 {
1924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1925 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1926 goto handle_failure;
1927 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1928 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1929 + sizeof(tHalCfg) + tlvStruct->length) ;
1930
1931 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1932 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1933 tlvStruct->length = sizeof(tANI_U32);
1934 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1935
1936 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1937 configDataValue ) != eSIR_SUCCESS)
1938 {
1939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1940 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1941 goto handle_failure;
1942 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1943 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1944 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1945
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1946 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1947 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1948 tlvStruct->length = sizeof(tANI_U32);
1949 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1950
1951 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1952 configDataValue ) != eSIR_SUCCESS)
1953 {
1954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1955 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1956 goto handle_failure;
1957 }
1958 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1959 + sizeof(tHalCfg) + tlvStruct->length) ;
1960
1961 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1962 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1963 tlvStruct->length = sizeof(tANI_U32);
1964 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1965
1966 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1967 configDataValue ) != eSIR_SUCCESS)
1968 {
1969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1970 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1971 goto handle_failure;
1972 }
1973 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1974 + sizeof(tHalCfg) + tlvStruct->length) ;
1975
1976 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1977 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1978 tlvStruct->length = sizeof(tANI_U32);
1979 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1980
1981 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1982 configDataValue ) != eSIR_SUCCESS)
1983 {
1984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1985 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1986 goto handle_failure;
1987 }
1988 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1989 + sizeof(tHalCfg) + tlvStruct->length) ;
1990
1991 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1992 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1993 tlvStruct->length = sizeof(tANI_U32);
1994 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1995
1996 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1997 configDataValue ) != eSIR_SUCCESS)
1998 {
1999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2000 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
2001 goto handle_failure;
2002 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]2003 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2004 + sizeof(tHalCfg) + tlvStruct->length) ;
2005
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]2006 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
2007 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
2008 tlvStruct->length = sizeof(tANI_U32);
2009 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2010
2011 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
2012 configDataValue ) != eSIR_SUCCESS)
2013 {
2014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2015 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
2016 goto handle_failure;
2017 }
2018 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2019 + sizeof(tHalCfg) + tlvStruct->length) ;
2020
2021 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
2022 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
2023 tlvStruct->length = sizeof(tANI_U32);
2024 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2025
2026 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
2027 configDataValue ) != eSIR_SUCCESS)
2028 {
2029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2030 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
2031 goto handle_failure;
2032 }
2033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2034 + sizeof(tHalCfg) + tlvStruct->length) ;
2035
2036 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
2037 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
2038 tlvStruct->length = sizeof(tANI_U32);
2039 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2040
2041 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
2042 configDataValue ) != eSIR_SUCCESS)
2043 {
2044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2045 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
2046 goto handle_failure;
2047 }
2048 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2049 + sizeof(tHalCfg) + tlvStruct->length) ;
2050
2051 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
2052 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
2053 tlvStruct->length = sizeof(tANI_U32);
2054 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2055
2056 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
2057 configDataValue ) != eSIR_SUCCESS)
2058 {
2059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2060 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
2061 goto handle_failure;
2062 }
2063 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2064 + sizeof(tHalCfg) + tlvStruct->length) ;
2065
2066 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
2067 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
2068 tlvStruct->length = sizeof(tANI_U32);
2069 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2070
2071 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
2072 configDataValue ) != eSIR_SUCCESS)
2073 {
2074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2075 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
2076 goto handle_failure;
2077 }
2078 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2079 + sizeof(tHalCfg) + tlvStruct->length) ;
2080
2081 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
2082 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
2083 tlvStruct->length = sizeof(tANI_U32);
2084 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2085
2086 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
2087 configDataValue ) != eSIR_SUCCESS)
2088 {
2089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2090 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2091 goto handle_failure;
2092 }
2093 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2094 + sizeof(tHalCfg) + tlvStruct->length) ;
2095
2096 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2097 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2098 tlvStruct->length = sizeof(tANI_U32);
2099 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2100
2101 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2102 configDataValue ) != eSIR_SUCCESS)
2103 {
2104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2105 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2106 goto handle_failure;
2107 }
2108 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2109 + sizeof(tHalCfg) + tlvStruct->length) ;
2110
2111 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2112 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2113 tlvStruct->length = sizeof(tANI_U32);
2114 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2115
2116 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2117 configDataValue ) != eSIR_SUCCESS)
2118 {
2119 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2120 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2121 goto handle_failure;
2122 }
2123 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2124 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu03d961b2014-09-19 16:45:00 +0530[diff] [blame]2125
2126 /* QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE */
2127 tlvStruct->type = QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE ;
2128 tlvStruct->length = sizeof(tANI_U32);
2129 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2130
2131 if (wlan_cfgGetInt(pMac, WNI_CFG_BURST_MODE_BE_TXOP_VALUE,
2132 configDataValue ) != eSIR_SUCCESS)
2133 {
2134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2135 "Failed to get value for WNI_CFG_BURST_MODE_BE_TXOP_VALUE");
2136 goto handle_failure;
2137 }
2138 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2139 + sizeof(tHalCfg) + tlvStruct->length) ;
2140
Deepthi Gowri9025aa62014-11-07 19:45:36 +0530[diff] [blame]2141 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_RA_START_RATE */
2142 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_RA_START_RATE ;
2143 tlvStruct->length = sizeof(tANI_U32);
2144 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2145
2146 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_RA_START_RATE,
2147 configDataValue ) != eSIR_SUCCESS)
2148 {
2149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2150 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_RA_START_RATE");
2151 goto handle_failure;
2152 }
2153 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2154 + sizeof(tHalCfg) + tlvStruct->length) ;
2155
Naresh Jayaramf5bbe3f2014-12-29 18:32:47 +0530[diff] [blame]2156 /* QWLAN_HAL_CFG_BTC_FAST_WLAN_CONN_PREF */
2157 tlvStruct->type = QWLAN_HAL_CFG_BTC_FAST_WLAN_CONN_PREF ;
2158 tlvStruct->length = sizeof(tANI_U32);
2159 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2160
2161 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FAST_WLAN_CONN_PREF,
2162 configDataValue ) != eSIR_SUCCESS)
2163 {
2164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2165 "Failed to get value for WNI_CFG_BTC_FAST_WLAN_CONN_PREF");
2166 goto handle_failure;
2167 }
2168 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2169 + sizeof(tHalCfg) + tlvStruct->length) ;
Deepthi Gowri9025aa62014-11-07 19:45:36 +0530[diff] [blame]2170
jagadeeshaf2d0ce2015-03-31 11:45:30 +0530[diff] [blame]2171 /* QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT */
2172 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT;
2173 tlvStruct->length = sizeof(tANI_U32);
2174 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2175
2176 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_RTSCTS_HTVHT,
2177 configDataValue ) != eSIR_SUCCESS)
2178 {
2179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2180 "Failed to get value for WNI_CFG_ENABLE_RTSCTS_HTVHT");
2181 goto handle_failure;
2182 }
2183 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2184 + sizeof(tHalCfg) + tlvStruct->length) ;
2185
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2186
2187 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN */
2188 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN ;
2189 tlvStruct->length = sizeof(tANI_U32);
2190 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2191
2192 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN,
2193 configDataValue ) != eSIR_SUCCESS)
2194 {
2195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2196 "Failed to get value for WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN");
2197 goto handle_failure;
2198 }
2199 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2200 + sizeof(tHalCfg) + tlvStruct->length) ;
2201
2202 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN */
2203 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN ;
2204 tlvStruct->length = sizeof(tANI_U32);
2205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2206
2207 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN,
2208 configDataValue ) != eSIR_SUCCESS)
2209 {
2210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2211 "Failed to get value for WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN");
2212 goto handle_failure;
2213 }
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2214 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2215 + sizeof(tHalCfg) + tlvStruct->length) ;
2216
Hanumantha Reddy Pothula9a8ccab2015-07-03 14:33:17 +0530[diff] [blame]2217 /* QWLAN_HAL_CFG_LINK_FAIL_TIMEOUT */
2218 tlvStruct->type = QWLAN_HAL_CFG_LINK_FAIL_TIMEOUT ;
2219 tlvStruct->length = sizeof(tANI_U32);
2220 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2221
2222 if (wlan_cfgGetInt(pMac, WNI_CFG_LINK_FAIL_TIMEOUT,
2223 configDataValue ) != eSIR_SUCCESS)
2224 {
2225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2226 "Failed to get value for WNI_CFG_LINK_FAIL_TIMEOUT");
2227 goto handle_failure;
2228 }
2229 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2230 + sizeof(tHalCfg) + tlvStruct->length) ;
2231
2232 /* QWLAN_HAL_CFG_LINK_FAIL_TX_CNT */
2233 tlvStruct->type = QWLAN_HAL_CFG_LINK_FAIL_TX_CNT ;
2234 tlvStruct->length = sizeof(tANI_U32);
2235 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2236
2237 if (wlan_cfgGetInt(pMac, WNI_CFG_LINK_FAIL_TX_CNT,
2238 configDataValue ) != eSIR_SUCCESS)
2239 {
2240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2241 "Failed to get value for WNI_CFG_LINK_FAIL_TX_CNT");
2242 goto handle_failure;
2243 }
2244 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2245 + sizeof(tHalCfg) + tlvStruct->length) ;
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2246
Hanumantha Reddy Pothulae0216f92015-08-11 18:30:06 +0530[diff] [blame]2247 /* QWLAN_HAL_CFG_TOGGLE_ARP_BDRATES */
2248 tlvStruct->type = QWLAN_HAL_CFG_TOGGLE_ARP_BDRATES;
2249 tlvStruct->length = sizeof(tANI_U32);
2250 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2251
2252 if (wlan_cfgGetInt(pMac, WNI_CFG_TOGGLE_ARP_BDRATES,
2253 configDataValue ) != eSIR_SUCCESS)
2254 {
2255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2256 "Failed to get value for WNI_CFG_TOGGLE_ARP_BDRATES");
2257 goto handle_failure;
2258 }
2259 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2260 + sizeof(tHalCfg) + tlvStruct->length) ;
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]2261 /* QWLAN_HAL_CFG_OPTIMIZE_CA_EVENT */
2262 tlvStruct->type = QWLAN_HAL_CFG_OPTIMIZE_CA_EVENT ;
2263 tlvStruct->length = sizeof(tANI_U32);
2264 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2265 if (wlan_cfgGetInt(pMac, WNI_CFG_OPTIMIZE_CA_EVENT,
2266 configDataValue ) != eSIR_SUCCESS)
2267 {
2268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2269 "Failed to get value for WNI_CFG_OPTIMIZE_CA_EVENT");
2270 goto handle_failure;
2271 }
2272 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2273 + sizeof(tHalCfg) + tlvStruct->length) ;
Hanumantha Reddy Pothulae0216f92015-08-11 18:30:06 +0530[diff] [blame]2274
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2275 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2276#ifdef WLAN_DEBUG
2277 {
2278 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2279 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2280 "****** Dumping CFG TLV ***** ");
2281 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2282 {
2283 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2284 "%02x %02x %02x %02x %02x %02x %02x %02x",
2285 tlvStructStart[i],
2286 tlvStructStart[i+1],
2287 tlvStructStart[i+2],
2288 tlvStructStart[i+3],
2289 tlvStructStart[i+4],
2290 tlvStructStart[i+5],
2291 tlvStructStart[i+6],
2292 tlvStructStart[i+7]);
2293 }
2294 /* Dump the bytes in the last line*/
2295 for (; i < wdiStartParams->usConfigBufferLen; i++)
2296 {
2297 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2298 "%02x ",tlvStructStart[i]);
2299 }
2300 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2301 "**************************** ");
2302 }
2303#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2304 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2305handle_failure:
2306 vos_mem_free(configParam);
2307 return VOS_STATUS_E_FAILURE;
2308}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2309/*
2310 * FUNCTION: WDA_wdiCompleteCB
2311 * call the voss call back function
2312 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2313void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2314{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2315 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2316 tWDA_CbContext *wdaContext;
2317
2318 if(NULL == pWdaParams)
2319 {
2320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2321 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2322 VOS_ASSERT(0) ;
2323 return ;
2324 }
2325
2326 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2327
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2328 if (NULL == wdaContext)
2329 {
2330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2331 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2332 return ;
2333 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2334
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2336 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2337 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2338 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2339 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2340 vos_mem_free(pWdaParams);
2341
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2342 if(WDI_STATUS_SUCCESS != status)
2343 {
2344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2345 "WDI stop callback returned failure" );
2346 VOS_ASSERT(0) ;
2347 }
2348 else
2349 {
2350 wdaContext->wdaState = WDA_STOP_STATE;
2351 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2352
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2353 /* FTM Driver stop procedure should be synced.
2354 * Stop and Close will happen on same context */
2355 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2356 {
2357 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2358 {
2359 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2360 "%s: FTM Stop Event Set Fail", __func__);
2361 VOS_ASSERT(0);
2362 }
2363 }
2364
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2365 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2366 vos_WDAComplete_cback(wdaContext->pVosContext);
2367
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2368 return ;
2369}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2370/*
2371 * FUNCTION: WDA_stop
2372 * call WDI_stop
2373 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2374VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2375{
2376 WDI_Status wdiStatus;
2377 VOS_STATUS status = VOS_STATUS_SUCCESS;
2378 WDI_StopReqParamsType *wdiStopReq;
2379 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2380 tWDA_ReqParams *pWdaParams ;
2381
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2382 if (NULL == pWDA)
2383 {
2384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2385 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2386 VOS_ASSERT(0);
2387 return VOS_STATUS_E_FAILURE;
2388 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2389 if (pWDA->wdiFailed == true)
2390 {
2391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2392 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2393 return VOS_STATUS_E_ALREADY;
2394 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2395
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2396 /* FTM mode stay START_STATE */
2397 if( (WDA_READY_STATE != pWDA->wdaState) &&
2398 (WDA_INIT_STATE != pWDA->wdaState) &&
2399 (WDA_START_STATE != pWDA->wdaState) )
2400 {
2401 VOS_ASSERT(0);
2402 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2403 wdiStopReq = (WDI_StopReqParamsType *)
2404 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2405 if(NULL == wdiStopReq)
2406 {
2407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2408 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2409 VOS_ASSERT(0);
2410 return VOS_STATUS_E_NOMEM;
2411 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2412
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2413 wdiStopReq->wdiStopReason = reason;
2414 wdiStopReq->wdiReqStatusCB = NULL;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2415
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2416 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2417 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 {
2419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2420 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 VOS_ASSERT(0);
2422 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2423 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2424 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2425
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2426 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2427 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2428 {
2429 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2430 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2431 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2432
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2433 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2434 pWdaParams->wdaMsgParam = NULL;
2435 pWdaParams->pWdaContext = pWDA;
2436
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2437 /* call WDI stop */
2438 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2439 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2440
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2441 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2442 {
2443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2444 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2445 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2446 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2447 status = VOS_STATUS_E_FAILURE;
2448 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2449
2450 /* FTM Driver stop procedure should be synced.
2451 * Stop and Close will happen on same context */
2452 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2453 {
2454 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2455 WDI_RESPONSE_TIMEOUT);
2456 if (status != VOS_STATUS_SUCCESS)
2457 {
2458 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2459 "%s: FTM Stop Timepoout", __func__);
2460 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2461 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2462 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2463 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464 return status;
2465}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2466/*
2467 * FUNCTION: WDA_close
2468 * call WDI_close and free the WDA context
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2469 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2470VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2471{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2472 VOS_STATUS status = VOS_STATUS_SUCCESS;
2473 WDI_Status wstatus;
2474 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2475 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2476 if (NULL == wdaContext)
2477 {
2478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2479 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2480 return VOS_STATUS_E_FAILURE;
2481 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2482 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2483 (WDA_STOP_STATE != wdaContext->wdaState))
2484 {
2485 VOS_ASSERT(0);
2486 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2487 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2488 wstatus = WDI_Close();
2489 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2490 {
2491 status = VOS_STATUS_E_FAILURE;
2492 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2493 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2494 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2495 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2496 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2497 {
2498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2499 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2500 status = VOS_STATUS_E_FAILURE;
2501 }
2502
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2503 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2504 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2505 {
2506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2507 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2508 status = VOS_STATUS_E_FAILURE;
2509 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2510 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2511 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2512 {
2513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2514 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2515 status = VOS_STATUS_E_FAILURE;
2516 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2517 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2518 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2519 {
2520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2521 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2522 status = VOS_STATUS_E_FAILURE;
2523 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2525 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2526 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2527 {
2528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2529 "error in WDA close " );
2530 status = VOS_STATUS_E_FAILURE;
2531 }
2532 return status;
2533}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2534/*
2535 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2536 * returns 1 if the compiled version is greater than or equal to the input version
2537 */
2538
2539uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2540{
2541 VOS_STATUS status = VOS_STATUS_SUCCESS;
2542 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2543 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2544 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2545 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2546 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2547 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2548 (compiledVersion.revision >= revision)))
2549 return 1;
2550 else
2551 return 0;
2552}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2553/*
2554 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2555 * returns 1 if the compiled version is greater than or equal to the input version
2556 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2557uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2558{
2559 VOS_STATUS status = VOS_STATUS_SUCCESS;
2560 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2561 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2562 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2563 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2564 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2565 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2566 (reportedVersion.revision >= revision)))
2567 return 1;
2568 else
2569 return 0;
2570}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2571/*
2572 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2573 * Returns the version of the WCNSS WLAN API with which the HOST
2574 * device driver was compiled
2575 */
2576VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2577 tSirVersionType *pVersion)
2578{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2579 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2580 if ((NULL == pvosGCtx) || (NULL == pVersion))
2581 {
2582 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2583 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2584 VOS_ASSERT(0);
2585 return VOS_STATUS_E_FAILURE;
2586 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2588 if (NULL == pWDA )
2589 {
2590 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2591 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2592 VOS_ASSERT(0);
2593 return VOS_STATUS_E_FAILURE;
2594 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2595 *pVersion = pWDA->wcnssWlanCompiledVersion;
2596 return VOS_STATUS_SUCCESS;
2597}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2598/*
2599 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2600 * Returns the version of the WCNSS WLAN API with which the WCNSS
2601 * device driver was compiled
2602 */
2603VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2604 tSirVersionType *pVersion)
2605{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2606 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2607 if ((NULL == pvosGCtx) || (NULL == pVersion))
2608 {
2609 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2610 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611 VOS_ASSERT(0);
2612 return VOS_STATUS_E_FAILURE;
2613 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2614 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2615 if (NULL == pWDA )
2616 {
2617 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2618 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2619 VOS_ASSERT(0);
2620 return VOS_STATUS_E_FAILURE;
2621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 *pVersion = pWDA->wcnssWlanReportedVersion;
2623 return VOS_STATUS_SUCCESS;
2624}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2625/*
2626 * FUNCTION: WDA_GetWcnssSoftwareVersion
2627 * Returns the WCNSS Software version string
2628 */
2629VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2630 tANI_U8 *pVersion,
2631 tANI_U32 versionBufferSize)
2632{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2633 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2634 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2635 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2636 if ((NULL == pvosGCtx) || (NULL == pVersion))
2637 {
2638 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2639 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2640 VOS_ASSERT(0);
2641 return VOS_STATUS_E_FAILURE;
2642 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2643 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2644 if (NULL == pWDA )
2645 {
2646 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2647 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2648 VOS_ASSERT(0);
2649 return VOS_STATUS_E_FAILURE;
2650 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2652 return VOS_STATUS_SUCCESS;
2653}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2654/*
2655 * FUNCTION: WDA_GetWcnssHardwareVersion
2656 * Returns the WCNSS Hardware version string
2657 */
2658VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2659 tANI_U8 *pVersion,
2660 tANI_U32 versionBufferSize)
2661{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2662 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2663 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2664 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2665 if ((NULL == pvosGCtx) || (NULL == pVersion))
2666 {
2667 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2668 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2669 VOS_ASSERT(0);
2670 return VOS_STATUS_E_FAILURE;
2671 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2672 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2673 if (NULL == pWDA )
2674 {
2675 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2676 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2677 VOS_ASSERT(0);
2678 return VOS_STATUS_E_FAILURE;
2679 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2680 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2681 return VOS_STATUS_SUCCESS;
2682}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2683/*
2684 * FUNCTION: WDA_WniCfgDnld
2685 * Trigger CFG Download
2686 */
2687VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2688{
2689 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2690 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2691
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2692 if (NULL == pMac )
2693 {
2694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2695 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 VOS_ASSERT(0);
2697 return VOS_STATUS_E_FAILURE;
2698 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2699 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2700 return vosStatus;
2701}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2702/* -----------------------------------------------------------------
2703 * WDI interface
2704 * -----------------------------------------------------------------
2705 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2706/*
2707 * FUNCTION: WDA_suspendDataTxCallback
2708 * call back function called from TL after suspend Transmission
2709 */
2710VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2711 v_U8_t* ucSTAId,
2712 VOS_STATUS vosStatus)
2713{
2714 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2716 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2717 if (NULL == pWDA )
2718 {
2719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2720 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2721 VOS_ASSERT(0);
2722 return VOS_STATUS_E_FAILURE;
2723 }
2724 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2725 {
2726 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2727 }
2728 else
2729 {
2730 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2731 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2732 /* Trigger the event to bring the WDA TL suspend function to come
2733 * out of wait*/
2734 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2735 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2736 {
2737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2738 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2740 /* If TL suspended had timedout before this callback was called, resume back
2741 * TL.*/
2742 if (pWDA->txSuspendTimedOut)
2743 {
2744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2745 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2746 WDA_ResumeDataTx(pWDA);
2747 pWDA->txSuspendTimedOut = FALSE;
2748 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2749 return VOS_STATUS_SUCCESS;
2750}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2751/*
2752 * FUNCTION: WDA_suspendDataTx
2753 * Update TL to suspend the data Transmission
2754 */
2755VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2756{
2757 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2758 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2759
2760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2761 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2762 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2763 if (pWDA->txSuspendTimedOut)
2764 {
2765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2766 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2767 return status;
2768 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2769 /* Reset the event to be not signalled */
2770 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2771 if(!VOS_IS_STATUS_SUCCESS(status))
2772 {
2773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2774 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2775 return VOS_STATUS_E_FAILURE;
2776 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2777 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2778 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2779 WDA_SuspendDataTxCallback);
2780 if(status != VOS_STATUS_SUCCESS)
2781 {
2782 return status;
2783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2784 /* Wait for the event to be set by the TL, to get the response of
2785 * suspending the TX queues, this event should be set by the Callback
2786 * function called by TL*/
2787 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2788 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2789 if(!VOS_IS_STATUS_SUCCESS(status))
2790 {
2791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2792 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2793 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2794 /* Set this flag to true when TL suspend times out, so that when TL
2795 * suspend eventually happens and calls the callback, TL can be resumed
2796 * right away by looking at this flag when true.*/
2797 pWDA->txSuspendTimedOut = TRUE;
2798 }
2799 else
2800 {
2801 pWDA->txSuspendTimedOut = FALSE;
2802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2803 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2804 {
2805 status = VOS_STATUS_SUCCESS;
2806 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2807 return status;
2808}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809/*
2810 * FUNCTION: WDA_resumeDataTx
2811 * Update TL to resume the data Transmission
2812 */
2813VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2814{
2815 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2816
2817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2818 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2819
2820 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 return status;
2822}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2823/*
2824 * FUNCTION: WDA_InitScanReqCallback
2825 * Trigger Init SCAN callback
2826 */
2827void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2828{
2829 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2830 tWDA_CbContext *pWDA;
2831 tInitScanParams *pWDA_ScanParam ;
2832 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2834 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2835 if(NULL == pWdaParams)
2836 {
2837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2838 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2839 VOS_ASSERT(0) ;
2840 return ;
2841 }
2842 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2843 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2844 if(NULL == pWDA_ScanParam)
2845 {
2846 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2847 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2848 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2849 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2850 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2851 return ;
2852 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2853 if(WDI_STATUS_SUCCESS != wdiStatus)
2854 {
2855 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2856 if(VOS_STATUS_SUCCESS != status)
2857 {
2858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2859 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2860 }
2861 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2862 /* free WDI command buffer */
2863 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2864 vos_mem_free(pWdaParams) ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2865
2866
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 /* without converting the Status to Failure or Success Just
2869 pass the same status to lim */
2870 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2871 /* send SCAN RSP message back to PE */
2872 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2873 return ;
2874}
2875
2876/*
2877 * FUNCTION: WDA_ProcessInitScanReq
2878 * Trigger Init SCAN in DAL
2879 */
2880VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2881 tInitScanParams *initScanParams)
2882{
2883 WDI_Status status = WDI_STATUS_SUCCESS ;
2884 WDI_InitScanReqParamsType *wdiInitScanParam =
2885 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2886 sizeof(WDI_InitScanReqParamsType)) ;
2887 tWDA_ReqParams *pWdaParams;
2888 tANI_U8 i = 0;
2889
2890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2891 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2892 if(NULL == wdiInitScanParam)
2893 {
2894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2895 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2896 VOS_ASSERT(0);
2897 return VOS_STATUS_E_NOMEM;
2898 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2899 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2900 if(NULL == pWdaParams)
2901 {
2902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2903 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 VOS_ASSERT(0);
2905 vos_mem_free(wdiInitScanParam);
2906 return VOS_STATUS_E_NOMEM;
2907 }
2908
2909 /* Copy init Scan params to WDI structure */
2910 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2911 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2912 sizeof(tSirMacAddr)) ;
2913 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2914 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2915 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2916 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2917 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2918 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2919 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2921 {
2922 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2923 initScanParams->scanEntry.bssIdx[i] ;
2924 }
2925
2926 /* if Frame length, copy macMgmtHdr or WDI structure */
2927 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2928 {
2929 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2930 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2931 }
2932 wdiInitScanParam->wdiReqStatusCB = NULL ;
2933
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2934 /* Store Init Req pointer, as this will be used for response */
2935 pWdaParams->pWdaContext = pWDA;
2936 pWdaParams->wdaMsgParam = initScanParams;
2937 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2938 /* first try to suspend TX */
2939 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2940 if(WDI_STATUS_SUCCESS != status)
2941 {
2942 goto handleWdiFailure;
2943 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2944 /* call DAL API to pass init scan request to DAL */
2945 status = WDI_InitScanReq(wdiInitScanParam,
2946 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2947 if(IS_WDI_STATUS_FAILURE(status))
2948 {
2949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2950 "error in WDA Init Scan, Resume Tx " );
2951 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2952 VOS_ASSERT(0) ;
2953
2954 goto handleWdiFailure;
2955 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2956 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2957handleWdiFailure:
2958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2959 "Failure in WDI Api, free all the memory " );
2960 /* free WDI command buffer */
2961 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2962 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2963 /* send Failure to PE */
2964 initScanParams->status = eSIR_FAILURE ;
2965 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2966 return CONVERT_WDI2VOS_STATUS(status) ;
2967}
2968
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2969/*
2970 * FUNCTION: WDA_StartScanReqCallback
2971 * send Start SCAN RSP back to PE
2972 */
2973void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2974 void* pUserData)
2975{
2976 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2977 tWDA_CbContext *pWDA;
2978 tStartScanParams *pWDA_ScanParam;
2979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2980 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2981 if(NULL == pWdaParams)
2982 {
2983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2984 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2985 VOS_ASSERT(0) ;
2986 return ;
2987 }
2988 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2989 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2990 if(NULL == pWDA_ScanParam)
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: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2994 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2995 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2996 return ;
2997 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2998 if(NULL == pWdaParams->wdaWdiApiMsgParam)
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: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3002 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3003 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3004 return ;
3005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3007 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3008
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3009
3010 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3011 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3012 /* send SCAN RSP message back to PE */
3013 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3014 return ;
3015}
3016
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3017/*
3018 * FUNCTION: WDA_ProcessStartScanReq
3019 * Trigger start SCAN in WDI
3020 */
3021VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
3022 tStartScanParams *startScanParams)
3023{
3024 WDI_Status status = WDI_STATUS_SUCCESS;
3025 WDI_StartScanReqParamsType *wdiStartScanParams =
3026 (WDI_StartScanReqParamsType *)vos_mem_malloc(
3027 sizeof(WDI_StartScanReqParamsType)) ;
3028 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3030 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3031 if(NULL == wdiStartScanParams)
3032 {
3033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3034 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3035 VOS_ASSERT(0);
3036 return VOS_STATUS_E_NOMEM;
3037 }
3038 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3039 if(NULL == pWdaParams)
3040 {
3041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3042 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3043 VOS_ASSERT(0);
3044 vos_mem_free(wdiStartScanParams);
3045 return VOS_STATUS_E_NOMEM;
3046 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3047 /* Copy init Scan params to WDI structure */
3048 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
3049 wdiStartScanParams->wdiReqStatusCB = NULL ;
3050
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3051 /* Store Init Req pointer, as this will be used for response */
3052 /* store Params pass it to WDI */
3053 pWdaParams->pWdaContext = pWDA;
3054 pWdaParams->wdaMsgParam = startScanParams;
3055 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3056 /* call DAL API to pass init scan request to DAL */
3057 status = WDI_StartScanReq(wdiStartScanParams,
3058 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3059 /* failure returned by WDI API */
3060 if(IS_WDI_STATUS_FAILURE(status))
3061 {
3062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3063 "Failure in Start Scan WDI API, free all the memory "
3064 "It should be due to previous abort scan." );
3065 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3066 vos_mem_free(pWdaParams) ;
3067 startScanParams->status = eSIR_FAILURE ;
3068 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
3069 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3070 return CONVERT_WDI2VOS_STATUS(status) ;
3071}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3072/*
3073 * FUNCTION: WDA_EndScanReqCallback
3074 * END SCAN callback
3075 */
3076void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
3077{
3078 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3079 tWDA_CbContext *pWDA;
3080 tEndScanParams *endScanParam;
3081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3082 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3083 if(NULL == pWdaParams)
3084 {
3085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3086 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 VOS_ASSERT(0) ;
3088 return ;
3089 }
3090 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3091 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3092 if(NULL == endScanParam)
3093 {
3094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3095 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3096 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3097 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3098 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3099 return ;
3100 }
3101
3102 /* Free WDI command buffer */
3103 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3104 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3105 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3106 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3107 /* send response back to PE */
3108 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
3109 return ;
3110}
3111
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3112/*
3113 * FUNCTION: WDA_ProcessEndScanReq
3114 * Trigger END SCAN in WDI
3115 */
3116VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
3117 tEndScanParams *endScanParams)
3118{
3119 WDI_Status status = WDI_STATUS_SUCCESS;
3120 WDI_EndScanReqParamsType *wdiEndScanParams =
3121 (WDI_EndScanReqParamsType *)vos_mem_malloc(
3122 sizeof(WDI_EndScanReqParamsType)) ;
3123 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3125 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3126 if(NULL == wdiEndScanParams)
3127 {
3128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3129 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3130 VOS_ASSERT(0);
3131 return VOS_STATUS_E_NOMEM;
3132 }
3133 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3134 if(NULL == pWdaParams)
3135 {
3136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3137 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3138 VOS_ASSERT(0);
3139 vos_mem_free(wdiEndScanParams);
3140 return VOS_STATUS_E_NOMEM;
3141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3142 /* Copy init Scan params to WDI structure */
3143 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
3144 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3145 /* Store Init Req pointer, as this will be used for response */
3146 /* store Params pass it to WDI */
3147 pWdaParams->pWdaContext = pWDA;
3148 pWdaParams->wdaMsgParam = endScanParams;
3149 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3150 /* call DAL API to pass init scan request to DAL */
3151 status = WDI_EndScanReq(wdiEndScanParams,
3152 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3153 if(IS_WDI_STATUS_FAILURE(status))
3154 {
3155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3156 "Failure in End Scan WDI API, free all the memory "
3157 "It should be due to previous abort scan." );
3158 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3159 vos_mem_free(pWdaParams) ;
3160 endScanParams->status = eSIR_FAILURE ;
3161 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
3162 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3163 return CONVERT_WDI2VOS_STATUS(status) ;
3164}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3165/*
3166 * FUNCTION: WDA_FinishScanReqCallback
3167 * Trigger Finish SCAN callback
3168 */
3169void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
3170{
3171 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3172 tWDA_CbContext *pWDA;
3173 tFinishScanParams *finishScanParam;
3174 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3176 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3177 if(NULL == pWdaParams)
3178 {
3179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3180 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3181 VOS_ASSERT(0) ;
3182 return ;
3183 }
3184
3185 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3186 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3187 if(NULL == finishScanParam)
3188 {
3189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3190 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3191 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3192 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3193 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3194 return ;
3195 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3196 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3197 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3198 /*
3199 * Now Resume TX, if we reached here means, TX is already suspended, we
3200 * have to resume it unconditionaly
3201 */
3202 status = WDA_ResumeDataTx(pWDA) ;
3203
3204 if(VOS_STATUS_SUCCESS != status)
3205 {
3206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3207 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3208 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3209 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3210 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
3211 return ;
3212}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3213/*
3214 * FUNCTION: WDA_ProcessFinshScanReq
3215 * Trigger Finish SCAN in WDI
3216 */
3217VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
3218 tFinishScanParams *finishScanParams)
3219{
3220 WDI_Status status = WDI_STATUS_SUCCESS;
3221 WDI_FinishScanReqParamsType *wdiFinishScanParams =
3222 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
3223 sizeof(WDI_FinishScanReqParamsType)) ;
3224 tWDA_ReqParams *pWdaParams ;
3225 tANI_U8 i = 0;
3226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3227 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3228 if(NULL == wdiFinishScanParams)
3229 {
3230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3231 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3232 VOS_ASSERT(0);
3233 return VOS_STATUS_E_NOMEM;
3234 }
3235 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3236 if(NULL == pWdaParams)
3237 {
3238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3239 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3240 VOS_ASSERT(0);
3241 vos_mem_free(wdiFinishScanParams);
3242 return VOS_STATUS_E_NOMEM;
3243 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3244 /* Copy init Scan params to WDI structure */
3245 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3246 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3247 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3248 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3249 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3250 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3251 finishScanParams->frameLength ;
3252 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3253 finishScanParams->currentOperChannel ;
3254 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3255 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3256 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3257 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3258 {
3259 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3260 finishScanParams->scanEntry.bssIdx[i] ;
3261 }
3262
3263
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3264 /* if Frame length, copy macMgmtHdr ro WDI structure */
3265 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3266 {
3267 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3268 &finishScanParams->macMgmtHdr,
3269 sizeof(WDI_MacMgmtHdr)) ;
3270 }
3271 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3272 /* Store Init Req pointer, as this will be used for response */
3273 /* store Params pass it to WDI */
3274 pWdaParams->pWdaContext = pWDA;
3275 pWdaParams->wdaMsgParam = finishScanParams;
3276 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3277 /* call DAL API to pass init scan request to DAL */
3278 status = WDI_FinishScanReq(wdiFinishScanParams,
3279 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3280
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3281
3282 /*
3283 * WDI API returns failure..
3284 */
3285 if(IS_WDI_STATUS_FAILURE( status))
3286 {
3287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3288 "Failure in Finish Scan WDI API, free all the memory " );
3289 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3290 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3291 finishScanParams->status = eSIR_FAILURE ;
3292 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3293 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3294 return CONVERT_WDI2VOS_STATUS(status) ;
3295}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3296/*---------------------------------------------------------------------
3297 * ASSOC API's
3298 *---------------------------------------------------------------------
3299 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3300/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3301 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3302 * Trigger Init SCAN callback
3303 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3304void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3305{
3306 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3307 tWDA_CbContext *pWDA;
3308 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3310 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3311 if(NULL == pWdaParams)
3312 {
3313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3314 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3315 VOS_ASSERT(0) ;
3316 return ;
3317 }
3318 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3319 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3320 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3321 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3322 /* reset macBSSID */
3323 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3324 /* reset macSTASelf */
3325 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3326 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3327 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3328 return ;
3329}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3330
3331/*
3332 * FUNCTION: WDA_JoinReqCallback
3333 * Free memory and send SWITCH CHANNEL RSP back to PE.
3334 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3335 */
3336void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3337{
3338 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3339 tWDA_CbContext *pWDA;
3340 tSwitchChannelParams *joinReqParam;
3341
3342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3343 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3344
3345 if(NULL == pWdaParams)
3346 {
3347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3348 "%s: pWdaParams received NULL", __func__);
3349 VOS_ASSERT(0);
3350 return;
3351 }
3352
3353 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3354 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3355 joinReqParam->status = wdiStatus;
3356
3357 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3358 {
3359 /* reset macBSSID */
3360 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3361 /* reset macSTASelf */
3362 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3363
3364 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3365 vos_mem_free(pWdaParams);
3366 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3367 }
3368
3369 return;
3370}
3371
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3372/*
3373 * FUNCTION: WDA_ProcessJoinReq
3374 * Trigger Join REQ in WDI
3375 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3376VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3377 tSwitchChannelParams* joinReqParam)
3378{
3379 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3380 WDI_JoinReqParamsType *wdiJoinReqParam =
3381 (WDI_JoinReqParamsType *)vos_mem_malloc(
3382 sizeof(WDI_JoinReqParamsType)) ;
3383 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3385 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3386 if(NULL == wdiJoinReqParam)
3387 {
3388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3389 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3390 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3391 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3392 return VOS_STATUS_E_NOMEM;
3393 }
3394 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3395 if(NULL == pWdaParams)
3396 {
3397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3398 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3399 VOS_ASSERT(0);
3400 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3401 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3402 return VOS_STATUS_E_NOMEM;
3403 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3404
3405 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3406 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3407 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3408 {
3409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3410 "%s: received join request when BSSID or self-STA is NULL "
3411 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3412 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3413 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3414 VOS_ASSERT(0);
3415 vos_mem_free(wdiJoinReqParam);
3416 vos_mem_free(pWdaParams);
3417 joinReqParam->status = eSIR_FAILURE ;
3418 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3419 return VOS_STATUS_E_INVAL;
3420 }
3421
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3422 /* copy the BSSID for pWDA */
3423 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3424 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3425 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3426 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3427 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3428 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3429#ifdef WLAN_FEATURE_VOWIFI
3430 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3431 joinReqParam->maxTxPower ;
3432#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3433 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3434 joinReqParam->localPowerConstraint ;
3435#endif
3436 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3437 joinReqParam->secondaryChannelOffset ;
3438 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3439
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3440 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3441 wdiJoinReqParam->pUserData = pWdaParams;
3442
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3443 /* Store Init Req pointer, as this will be used for response */
3444 /* store Params pass it to WDI */
3445 pWdaParams->pWdaContext = pWDA;
3446 pWdaParams->wdaMsgParam = joinReqParam;
3447 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3448 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3449 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3450 if(IS_WDI_STATUS_FAILURE(status))
3451 {
3452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3453 "Failure in Join WDI API, free all the memory " );
3454 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3455 vos_mem_free(pWdaParams) ;
3456 joinReqParam->status = eSIR_FAILURE ;
3457 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3458 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3459 return CONVERT_WDI2VOS_STATUS(status) ;
3460}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3461/*
3462 * FUNCTION: WDA_SwitchChannelReqCallback
3463 * send Switch channel RSP back to PE
3464 */
3465void WDA_SwitchChannelReqCallback(
3466 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3467{
3468 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3469 tWDA_CbContext *pWDA;
3470 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3472 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3473 if(NULL == pWdaParams)
3474 {
3475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3476 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3477 VOS_ASSERT(0) ;
3478 return ;
3479 }
3480 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3481 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3482
3483#ifdef WLAN_FEATURE_VOWIFI
3484 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3485#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3486 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3487 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3488 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3489 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3490 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3491 return ;
3492}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3493/*
3494 * FUNCTION: WDA_ProcessChannelSwitchReq
3495 * Request to WDI to switch channel REQ params.
3496 */
3497VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3498 tSwitchChannelParams *pSwitchChanParams)
3499{
3500 WDI_Status status = WDI_STATUS_SUCCESS ;
3501 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3502 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3503 sizeof(WDI_SwitchChReqParamsType)) ;
3504 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3506 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3507 if(NULL == wdiSwitchChanParam)
3508 {
3509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3510 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3511 VOS_ASSERT(0);
3512 return VOS_STATUS_E_NOMEM;
3513 }
3514 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3515 if(NULL == pWdaParams)
3516 {
3517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3518 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3519 VOS_ASSERT(0);
3520 vos_mem_free(wdiSwitchChanParam);
3521 return VOS_STATUS_E_NOMEM;
3522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3523 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3524#ifndef WLAN_FEATURE_VOWIFI
3525 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3526 pSwitchChanParams->localPowerConstraint;
3527#endif
3528 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3529 pSwitchChanParams->secondaryChannelOffset;
3530 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3531 /* Store req pointer, as this will be used for response */
3532 /* store Params pass it to WDI */
3533 pWdaParams->pWdaContext = pWDA;
3534 pWdaParams->wdaMsgParam = pSwitchChanParams;
3535 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3536#ifdef WLAN_FEATURE_VOWIFI
3537 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3538 = pSwitchChanParams->maxTxPower;
3539 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3540 pSwitchChanParams ->selfStaMacAddr,
3541 sizeof(tSirMacAddr));
3542#endif
3543 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3544 pSwitchChanParams->bssId,
3545 sizeof(tSirMacAddr));
3546
3547 status = WDI_SwitchChReq(wdiSwitchChanParam,
3548 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3549 if(IS_WDI_STATUS_FAILURE(status))
3550 {
3551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3552 "Failure in process channel switch Req WDI API, free all the memory " );
3553 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3554 vos_mem_free(pWdaParams) ;
3555 pSwitchChanParams->status = eSIR_FAILURE ;
3556 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3557 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 return CONVERT_WDI2VOS_STATUS(status) ;
3559}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3560
3561/*
3562 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3563 * send Switch channel RSP back to PE
3564 */
3565void WDA_SwitchChannelReqCallback_V1(
3566 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3567 void* pUserData)
3568{
3569 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3570 tWDA_CbContext *pWDA;
3571 tSwitchChannelParams *pSwitchChanParams;
3572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3573 "<------ %s " ,__func__);
3574
3575 if (NULL == pWdaParams)
3576 {
3577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3578 "%s: pWdaParams received NULL", __func__);
3579 VOS_ASSERT(0);
3580 return ;
3581 }
3582 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3583 pSwitchChanParams =
3584 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3585 pSwitchChanParams->channelSwitchSrc =
3586 wdiSwitchChanRsp->channelSwitchSrc;
3587#ifdef WLAN_FEATURE_VOWIFI
3588 pSwitchChanParams->txMgmtPower =
3589 wdiSwitchChanRsp->ucTxMgmtPower;
3590#endif
3591 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3592 vos_mem_free(pWdaParams);
3593 pSwitchChanParams->status =
3594 wdiSwitchChanRsp->wdiStatus ;
3595 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3596 (void *)pSwitchChanParams , 0);
3597 return;
3598}
3599
3600/*
3601 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3602 * Request to WDI to switch channel REQ params.
3603 */
3604VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3605 tSwitchChannelParams *pSwitchChanParams)
3606{
3607 WDI_Status status = WDI_STATUS_SUCCESS ;
3608 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3609 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3610 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3611 tWDA_ReqParams *pWdaParams ;
3612 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3613 "------> %s " ,__func__);
3614 if (NULL == wdiSwitchChanParam)
3615 {
3616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3617 "%s: VOS MEM Alloc Failure", __func__);
3618 VOS_ASSERT(0);
3619 return VOS_STATUS_E_NOMEM;
3620 }
3621 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3622 if (NULL == pWdaParams)
3623 {
3624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3625 "%s: VOS MEM Alloc Failure", __func__);
3626 VOS_ASSERT(0);
3627 vos_mem_free(wdiSwitchChanParam);
3628 return VOS_STATUS_E_NOMEM;
3629 }
3630 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3631 pSwitchChanParams->channelSwitchSrc;
3632
3633 wdiSwitchChanParam->wdiChInfo.ucChannel =
3634 pSwitchChanParams->channelNumber;
3635#ifndef WLAN_FEATURE_VOWIFI
3636 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3637 pSwitchChanParams->localPowerConstraint;
3638#endif
3639 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3640 pSwitchChanParams->secondaryChannelOffset;
3641 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3642 /* Store req pointer, as this will be used for response */
3643 /* store Params pass it to WDI */
3644 pWdaParams->pWdaContext = pWDA;
3645 pWdaParams->wdaMsgParam = pSwitchChanParams;
3646 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3647#ifdef WLAN_FEATURE_VOWIFI
3648 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3649 pSwitchChanParams->maxTxPower;
3650 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3651 pSwitchChanParams ->selfStaMacAddr,
3652 sizeof(tSirMacAddr));
3653#endif
3654 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3655 pSwitchChanParams->bssId,
3656 sizeof(tSirMacAddr));
3657
3658 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3659 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3660 pWdaParams);
3661 if (IS_WDI_STATUS_FAILURE(status))
3662 {
3663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3664 "Failure in process channel switch Req WDI "
3665 "API, free all the memory " );
3666 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3667 vos_mem_free(pWdaParams) ;
3668 pSwitchChanParams->status = eSIR_FAILURE ;
3669 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3670 (void *)pSwitchChanParams, 0) ;
3671 }
3672 return CONVERT_WDI2VOS_STATUS(status) ;
3673}
3674
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3675/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3676 * FUNCTION: WDA_ConfigBssRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3677 * config BSS Req Callback, called by WDI
3678 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3679void WDA_ConfigBssRspCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3680 ,void* pUserData)
3681{
3682 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3683 tWDA_CbContext *pWDA;
3684 tAddBssParams *configBssReqParam;
3685 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3687 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3688 if(NULL == pWdaParams)
3689 {
3690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3691 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3692 VOS_ASSERT(0) ;
3693 return ;
3694 }
3695 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3696 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3697 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3698 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3699 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3700 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3701 {
3702 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3703 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3704 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3705 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3706 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3707
3708 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3709 {
3710 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3711 {
3712 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3713 staConfigBssParam->staType = STA_ENTRY_BSSID;
3714 }
3715 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3716 (staConfigBssParam->staType == STA_ENTRY_SELF))
3717 {
3718 /* This is the 1st add BSS Req for the BTAMP STA */
3719 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3720 staConfigBssParam->staType = STA_ENTRY_BSSID;
3721 }
3722 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3723 (staConfigBssParam->staType == STA_ENTRY_PEER))
3724 {
3725 /* This is the 2nd ADD BSS Request that is sent
3726 * on the BTAMP STA side. The Sta type is
3727 * set to STA_ENTRY_PEER here.*/
3728 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3729 }
3730 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3731 (staConfigBssParam->staType == STA_ENTRY_SELF))
3732 {
3733 /* statype is already set by PE.
3734 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3735 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3736 staConfigBssParam->staType = STA_ENTRY_BSSID;
3737 }
3738 else
3739 {
3740 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3741 staConfigBssParam->staType = STA_ENTRY_PEER;
3742 }
3743 }
3744 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3745 {
3746 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3747 staConfigBssParam->staType = STA_ENTRY_SELF;
3748 }
3749 else
3750 {
3751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3752 "Invalid operation mode specified");
3753 VOS_ASSERT(0);
3754 }
3755
3756 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3757 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3758 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3760 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3761 sizeof(tSirMacAddr));
3762 staConfigBssParam->txChannelWidthSet =
3763 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3764 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3765 staConfigBssParam->htCapable)
3766 {
3767 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3768 wdiConfigBssRsp->ucBSSIdx;
3769 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3770 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3771 pWDA->wdaStaInfo[staConfigBssParam->staIdx].currentOperChan =
3772 configBssReqParam->currentOperChannel;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3773 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3774 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3775 wdiConfigBssRsp->ucBSSIdx,
3776 wdiConfigBssRsp->ucSTAIdx))
3777 {
3778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3779 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3780 VOS_ASSERT(0) ;
3781 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3782 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3783 {
3784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3785 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3786 VOS_ASSERT(0) ;
3787 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3788#ifdef WLAN_FEATURE_VOWIFI
3789 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3790#endif
3791 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]3792 else
3793 {
3794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3795 "%s: Failure with status %d", __func__,
3796 wdiConfigBssRsp->wdiStatus);
3797 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
3798 WLAN_LOG_INDICATOR_HOST_DRIVER,
3799 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
3800 FALSE, TRUE);
3801 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]3802 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
3803 sizeof(WDI_ConfigBSSReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3804 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3805 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3806 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3807 return ;
3808}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3809/*
3810 * FUNCTION: WDA_UpdateEdcaParamsForAC
3811 * Update WDI EDCA params with PE edca params
3812 */
3813void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3814 WDI_EdcaParamRecord *wdiEdcaParam,
3815 tSirMacEdcaParamRecord *macEdcaParam)
3816{
3817 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3818 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3819 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3820 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3821 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3822 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3823}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3824void WDA_ConfigBssReqCallback(WDI_Status wdiStatus,
3825 void* pUserData)
3826{
3827 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3828 tWDA_CbContext *pWDA;
3829 tAddBssParams *addBssParams;
3830
3831 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3832 "<------ %s, wdiStatus: %d",
3833 __func__, wdiStatus);
3834
3835 if (NULL == pWdaParams)
3836 {
3837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3838 "%s: Invalid pWdaParams pointer", __func__);
3839 VOS_ASSERT(0);
3840 return;
3841 }
3842
3843 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3844 addBssParams = (tAddBssParams *)pWdaParams->wdaMsgParam;
3845
3846 addBssParams->status = wdiStatus;
3847
3848 if (IS_WDI_STATUS_FAILURE(wdiStatus))
3849 {
3850 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3851 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]3852 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
3853 WLAN_LOG_INDICATOR_HOST_DRIVER,
3854 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
3855 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3856 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)addBssParams , 0);
3857 }
3858
3859 return ;
3860}
3861
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3862/*
3863 * FUNCTION: WDA_ProcessConfigBssReq
3864 * Configure BSS before starting Assoc with AP
3865 */
3866VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3867 tAddBssParams* configBssReqParam)
3868{
3869 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3870 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3871 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3873 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3874 if (NULL == configBssReqParam)
3875 {
3876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3877 "%s: configBssReqParam is NULL", __func__);
3878 return VOS_STATUS_E_INVAL;
3879 }
3880
3881 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3882 sizeof(WDI_ConfigBSSReqParamsType)) ;
3883
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3884 if(NULL == wdiConfigBssReqParam)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3888 VOS_ASSERT(0);
3889 return VOS_STATUS_E_NOMEM;
3890 }
3891 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3892 if(NULL == pWdaParams)
3893 {
3894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3895 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3896 VOS_ASSERT(0);
3897 vos_mem_free(wdiConfigBssReqParam);
3898 return VOS_STATUS_E_NOMEM;
3899 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3901 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3902 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3903 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3904 configBssReqParam) ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3905 wdiConfigBssReqParam->wdiReqStatusCB = WDA_ConfigBssReqCallback;
3906 wdiConfigBssReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3907 /* Store Init Req pointer, as this will be used for response */
3908 /* store Params pass it to WDI */
3909 pWdaParams->pWdaContext = pWDA;
3910 pWdaParams->wdaMsgParam = configBssReqParam;
3911 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3912 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3913 (WDI_ConfigBSSRspCb )WDA_ConfigBssRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3914 if(IS_WDI_STATUS_FAILURE(status))
3915 {
3916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3917 "Failure in Config BSS WDI API, free all the memory " );
3918 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3919 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3920 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3921 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3922 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3923 return CONVERT_WDI2VOS_STATUS(status) ;
3924}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3925#ifdef ENABLE_HAL_COMBINED_MESSAGES
3926/*
3927 * FUNCTION: WDA_PostAssocReqCallback
3928 * Post ASSOC req callback, send RSP back to PE
3929 */
3930void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3931 void* pUserData)
3932{
3933 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3934 tPostAssocParams *postAssocReqParam =
3935 (tPostAssocParams *)pWDA->wdaMsgParam ;
3936 /*STA context within the BSS Params*/
3937 tAddStaParams *staPostAssocParam =
3938 &postAssocReqParam->addBssParams.staContext ;
3939 /*STA Params for self STA*/
3940 tAddStaParams *selfStaPostAssocParam =
3941 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3943 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3944 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3945 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3946 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3947 {
3948 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3949 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3950 sizeof(tSirMacAddr)) ;
3951 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3952 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3953 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3954 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3955 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]3956 vos_mem_zero(pWDA->wdaWdiApiMsgParam, sizeof(WDI_PostAssocReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3957 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3958 pWDA->wdaWdiApiMsgParam = NULL;
3959 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3961 return ;
3962}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3963/*
3964 * FUNCTION: WDA_ProcessPostAssocReq
3965 * Trigger POST ASSOC processing in WDI
3966 */
3967VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3968 tPostAssocParams *postAssocReqParam)
3969{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3970 WDI_Status status = WDI_STATUS_SUCCESS ;
3971
3972 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3973 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3974 sizeof(WDI_PostAssocReqParamsType)) ;
3975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3976 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3977
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3978 if(NULL == wdiPostAssocReqParam)
3979 {
3980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3981 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3982 VOS_ASSERT(0);
3983 return VOS_STATUS_E_NOMEM;
3984 }
3985
3986 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3987 {
3988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3989 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3990 VOS_ASSERT(0);
3991 return VOS_STATUS_E_FAILURE;
3992 }
3993
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3994 /* update BSS params into WDI structure */
3995 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3996 &postAssocReqParam->addBssParams) ;
3997 /* update STA params into WDI structure */
3998 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3999 &postAssocReqParam->addStaParams) ;
4000
4001 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
4002 postAssocReqParam->addBssParams.highPerformance;
4003 WDA_UpdateEdcaParamsForAC(pWDA,
4004 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
4005 &postAssocReqParam->addBssParams.acbe);
4006 WDA_UpdateEdcaParamsForAC(pWDA,
4007 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
4008 &postAssocReqParam->addBssParams.acbk);
4009 WDA_UpdateEdcaParamsForAC(pWDA,
4010 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
4011 &postAssocReqParam->addBssParams.acvi);
4012 WDA_UpdateEdcaParamsForAC(pWDA,
4013 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
4014 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4015 /* Store Init Req pointer, as this will be used for response */
4016 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4017 /* store Params pass it to WDI */
4018 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4019 status = WDI_PostAssocReq(wdiPostAssocReqParam,
4020 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4021 if(IS_WDI_STATUS_FAILURE(status))
4022 {
4023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4024 "Failure in Post Assoc WDI API, free all the memory " );
4025 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
4026 pWDA->wdaWdiApiMsgParam = NULL;
4027 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4028 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4029 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
4030 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4031 return CONVERT_WDI2VOS_STATUS(status) ;
4032}
4033#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4034/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4035 * FUNCTION: WDA_AddStaRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4036 * ADD STA req callback, send RSP back to PE
4037 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4038void WDA_AddStaRspCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4039 void* pUserData)
4040{
4041 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4042 tWDA_CbContext *pWDA;
4043 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4045 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4046 if(NULL == pWdaParams)
4047 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4048 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]4049 VOS_ASSERT(0) ;
4050 return ;
4051 }
4052 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4053 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4054 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4055 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4056 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
4057 {
4058 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
4059 /*TODO: UMAC structure doesn't have these fields*/
4060 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
4061 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
4062 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
4063 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
4064 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
4065 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]4066#ifdef FEATURE_WLAN_TDLS
4067 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
4068 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
4069#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4070 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]4071#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4072 {
4073 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
4074 wdiConfigStaRsp->ucBssIdx;
4075 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
4076 WDA_VALID_STA_INDEX ;
Abhishek Singhf08a82b2014-10-07 11:00:42 +0530[diff] [blame]4077 pWDA->wdaStaInfo[addStaReqParam->staIdx].currentOperChan =
4078 addStaReqParam->currentOperChan;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4079 }
4080 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
4081 {
4082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4083 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4084 VOS_ASSERT(0) ;
4085 return ;
4086 }
4087 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4088 else
4089 {
4090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4091 "%s: Failure with status %d", __func__,
4092 wdiConfigStaRsp->wdiStatus);
4093 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4094 WLAN_LOG_INDICATOR_HOST_DRIVER,
4095 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4096 FALSE, TRUE);
4097 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4098 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
4099 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4100 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4101 return ;
4102}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4103void WDA_AddStaReqCallback(WDI_Status wdiStatus,
4104 void* pUserData)
4105{
4106 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4107 tWDA_CbContext *pWDA;
4108 tAddStaParams *addStaParams;
4109
4110 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4111 "<------ %s, wdiStatus: %d",
4112 __func__, wdiStatus);
4113
4114 if (NULL == pWdaParams)
4115 {
4116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4117 "%s: Invalid pWdaParams pointer", __func__);
4118 VOS_ASSERT(0);
4119 return;
4120 }
4121
4122 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4123 addStaParams = (tAddStaParams *)pWdaParams->wdaMsgParam;
4124
4125 addStaParams->status = wdiStatus;
4126
4127 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4128 {
4129 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4130 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4131 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4132 WLAN_LOG_INDICATOR_HOST_DRIVER,
4133 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4134 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4135 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaParams , 0);
4136 }
4137
4138 return ;
4139}
4140
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4141/*
4142 * FUNCTION: WDA_ConfigStaReq
4143 * Trigger Config STA processing in WDI
4144 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4145VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4146 tAddStaParams *addStaReqParam)
4147{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4148 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4149 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
4150 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
4151 sizeof(WDI_ConfigSTAReqParamsType)) ;
4152 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4153 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4154 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4155 if(NULL == wdiConfigStaReqParam)
4156 {
4157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4158 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159 VOS_ASSERT(0);
4160 return VOS_STATUS_E_NOMEM;
4161 }
4162 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4163 if(NULL == pWdaParams)
4164 {
4165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4166 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4167 VOS_ASSERT(0);
4168 vos_mem_free(wdiConfigStaReqParam);
4169 return VOS_STATUS_E_NOMEM;
4170 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4171 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4172 /* update STA params into WDI structure */
4173 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
4174 addStaReqParam) ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4175 wdiConfigStaReqParam->wdiReqStatusCB = WDA_AddStaReqCallback;
4176 wdiConfigStaReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4177 /* Store Init Req pointer, as this will be used for response */
4178 /* store Params pass it to WDI */
4179 pWdaParams->pWdaContext = pWDA;
4180 pWdaParams->wdaMsgParam = addStaReqParam;
4181 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4182
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4184 (WDI_ConfigSTARspCb )WDA_AddStaRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4185 if(IS_WDI_STATUS_FAILURE(status))
4186 {
4187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4188 "Failure in Config STA WDI API, free all the memory " );
4189 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4190 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4191 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4192 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
4193 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4194 return CONVERT_WDI2VOS_STATUS(status) ;
4195}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4196
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4197/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4198 * FUNCTION: WDA_DelBSSRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4199 * Dens DEL BSS RSP back to PE
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4200 */
4201void WDA_DelBSSRspCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4202 void* pUserData)
4203{
4204 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4205 tWDA_CbContext *pWDA;
4206 tDeleteBssParams *delBssReqParam;
4207 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4209 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4210 if(NULL == pWdaParams)
4211 {
4212 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4213 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4214 VOS_ASSERT(0) ;
4215 return ;
4216 }
4217 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4218 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4219 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4220 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
4221 {
4222 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
4223 sizeof(tSirMacAddr)) ;
4224 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4225 else
4226 {
4227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4228 "%s: Failure with status %d", __func__,
4229 wdiDelBssRsp->wdiStatus);
4230 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4231 WLAN_LOG_INDICATOR_HOST_DRIVER,
4232 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4233 FALSE, TRUE);
4234 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4235 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
4236 {
4237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4238 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4239 VOS_ASSERT(0) ;
4240 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4241 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
4242 {
4243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4244 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4245 VOS_ASSERT(0) ;
4246 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4247 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
4248 {
4249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4250 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4251 VOS_ASSERT(0) ;
4252 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4253
4254 WLANTL_StartForwarding(staIdx,0,0);
4255
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4256 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4257 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4258 /* reset the the system role*/
4259 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
4260
4261 /* Reset the BA related information */
4262 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
4263 {
4264 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
4265 {
4266 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
4267 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4268 pWDA->wdaStaInfo[staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4269 /* Reset framesTxed counters here */
4270 for(tid = 0; tid < STACFG_MAX_TC; tid++)
4271 {
4272 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
4273 }
4274 }
4275 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4276
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4277 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4278 return ;
4279}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4280void WDA_DelBSSReqCallback(WDI_Status wdiStatus,
4281 void* pUserData)
4282{
4283 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4284 tWDA_CbContext *pWDA;
4285 tDeleteBssParams *delbssParams;
4286
4287 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4288 "<------ %s, wdiStatus: %d",
4289 __func__, wdiStatus);
4290
4291 if (NULL == pWdaParams)
4292 {
4293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4294 "%s: Invalid pWdaParams pointer", __func__);
4295 VOS_ASSERT(0);
4296 return;
4297 }
4298
4299 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4300 delbssParams = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
4301
4302 delbssParams->status = wdiStatus ;
4303
4304 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4305 {
4306 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4307 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4308 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4309 WLAN_LOG_INDICATOR_HOST_DRIVER,
4310 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4311 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4312 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delbssParams , 0) ;
4313 }
4314
4315 return ;
4316}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4317
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4318/*
4319 * FUNCTION: WDA_ProcessDelBssReq
4320 * Init DEL BSS req with WDI
4321 */
4322VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
4323 tDeleteBssParams *delBssParam)
4324{
4325 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4326 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
4327 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
4328 sizeof(WDI_DelBSSReqParamsType)) ;
4329 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4331 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4332 if(NULL == wdiDelBssReqParam)
4333 {
4334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4335 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4336 VOS_ASSERT(0);
4337 return VOS_STATUS_E_NOMEM;
4338 }
4339 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4340 if(NULL == pWdaParams)
4341 {
4342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4343 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4344 VOS_ASSERT(0);
4345 vos_mem_free(wdiDelBssReqParam);
4346 return VOS_STATUS_E_NOMEM;
4347 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4348 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4349 wdiDelBssReqParam->wdiReqStatusCB = WDA_DelBSSReqCallback ;
4350 wdiDelBssReqParam->pUserData = pWdaParams;
4351
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4352 /* Store Init Req pointer, as this will be used for response */
4353 /* store Params pass it to WDI */
4354 pWdaParams->pWdaContext = pWDA;
4355 pWdaParams->wdaMsgParam = delBssParam;
4356 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4357
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4358 status = WDI_DelBSSReq(wdiDelBssReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4359 (WDI_DelBSSRspCb )WDA_DelBSSRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4360 if(IS_WDI_STATUS_FAILURE(status))
4361 {
4362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4363 "Failure in Del BSS WDI API, free all the memory " );
4364 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4365 vos_mem_free(pWdaParams) ;
4366 delBssParam->status = eSIR_FAILURE ;
4367 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
4368 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4369 return CONVERT_WDI2VOS_STATUS(status) ;
4370}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4371/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4372 * FUNCTION: WDA_DelSTARspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4373 * Dens DEL STA RSP back to PE
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4374 */
4375void WDA_DelSTARspCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4376 void* pUserData)
4377{
4378 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4379 tWDA_CbContext *pWDA;
4380 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4382 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4383 if(NULL == pWdaParams)
4384 {
4385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4386 "%s: pWdaParams received NULL", __func__);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4387 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4388 return ;
4389 }
4390 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4391 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4392 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4393 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
4394 {
4395 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
4396 {
4397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4398 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4399 VOS_ASSERT(0) ;
4400 }
4401 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4402 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4403 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4404 else
4405 {
4406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4407 "%s: Failure with status %d", __func__,
4408 wdiDelStaRsp->wdiStatus);
4409 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4410 WLAN_LOG_INDICATOR_HOST_DRIVER,
4411 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4412 FALSE, TRUE);
4413 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4414 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4415 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4416 /*Reset the BA information corresponding to this STAIdx */
4417 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4418 WDA_INVALID_STA_INDEX;
4419 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4420 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4421 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4422 return ;
4423}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4424void WDA_DelSTAReqCallback(WDI_Status wdiStatus,
4425 void* pUserData)
4426{
4427 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4428 tWDA_CbContext *pWDA;
4429 tDeleteStaParams *delStaParams;
4430
4431 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4432 "<------ %s, wdiStatus: %d",
4433 __func__, wdiStatus);
4434
4435 if (NULL == pWdaParams)
4436 {
4437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4438 "%s: Invalid pWdaParams pointer", __func__);
4439 VOS_ASSERT(0);
4440 return;
4441 }
4442
4443 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4444 delStaParams = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
4445
4446 delStaParams->status = wdiStatus ;
4447
4448 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4449 {
4450 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4451 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4452 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4453 WLAN_LOG_INDICATOR_HOST_DRIVER,
4454 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4455 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4456 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParams , 0) ;
4457 }
4458
4459 return ;
4460}
4461
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4462/*
4463 * FUNCTION: WDA_ProcessDelStaReq
4464 * Init DEL STA req with WDI
4465 */
4466VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4467 tDeleteStaParams *delStaParam)
4468{
4469 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4470 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4471 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4472 sizeof(WDI_DelSTAReqParamsType)) ;
4473 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4475 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4476 if(NULL == wdiDelStaReqParam)
4477 {
4478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4479 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4480 VOS_ASSERT(0);
4481 return VOS_STATUS_E_NOMEM;
4482 }
4483 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4484 if(NULL == pWdaParams)
4485 {
4486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4487 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4488 VOS_ASSERT(0);
4489 vos_mem_free(wdiDelStaReqParam);
4490 return VOS_STATUS_E_NOMEM;
4491 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4492 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4493 wdiDelStaReqParam->wdiReqStatusCB = WDA_DelSTAReqCallback ;
4494 wdiDelStaReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4495 /* Store Init Req pointer, as this will be used for response */
4496 /* store Params pass it to WDI */
4497 pWdaParams->pWdaContext = pWDA;
4498 pWdaParams->wdaMsgParam = delStaParam;
4499 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4500
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4501 status = WDI_DelSTAReq(wdiDelStaReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4502 (WDI_DelSTARspCb )WDA_DelSTARspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4503 if(IS_WDI_STATUS_FAILURE(status))
4504 {
4505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4506 "Failure in Del STA WDI API, free all the memory status = %d",
4507 status );
4508 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4509 vos_mem_free(pWdaParams) ;
4510 delStaParam->status = eSIR_FAILURE ;
4511 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4512 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4513 return CONVERT_WDI2VOS_STATUS(status) ;
4514}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4515void WDA_ProcessAddStaSelfRspCallback(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4516{
4517 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4518 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4519 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4521 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4522 if(NULL == pWdaParams)
4523 {
4524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4525 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4526 VOS_ASSERT(0) ;
4527 return ;
4528 }
4529 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4530 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4531 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4532 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4533 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4534 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4535 pwdiAddSTASelfRsp->macSelfSta,
4536 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4537 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4538 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4539 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4540 {
4541 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4542 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4544 "%s: Failure with status %d failcnter %d", __func__,
4545 pwdiAddSTASelfRsp->wdiStatus,
4546 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter);
4547 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4548 WLAN_LOG_INDICATOR_HOST_DRIVER,
4549 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4550 FALSE, TRUE);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4552 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4553 return ;
4554}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4555void WDA_ProcessAddStaSelfReqCallback(WDI_Status wdiStatus,
4556 void* pUserData)
4557{
4558 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4559 tWDA_CbContext *pWDA;
4560 tAddStaSelfParams *addStaSelfParams;
4561
4562 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4563 "<------ %s, wdiStatus: %d",
4564 __func__, wdiStatus);
4565
4566 if (NULL == pWdaParams)
4567 {
4568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4569 "%s: Invalid pWdaParams pointer", __func__);
4570 VOS_ASSERT(0);
4571 return;
4572 }
4573
4574 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4575 addStaSelfParams = (tAddStaSelfParams *)pWdaParams->wdaMsgParam;
4576
4577 addStaSelfParams->status = wdiStatus ;
4578
4579 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4580 {
4581 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4582 vos_mem_free(pWdaParams) ;
4583 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason
4584 = WDA_ADDSTA_REQ_WDI_FAIL;
4585 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4587 "%s: Failure with status %d failcnter %d", __func__,
4588 wdiStatus,
4589 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter);
4590 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4591 WLAN_LOG_INDICATOR_HOST_DRIVER,
4592 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4593 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4594 WDA_SendMsg(pWDA, WDA_ADD_STA_SELF_RSP, (void *)addStaSelfParams , 0);
4595 }
4596
4597 return ;
4598}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4599
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4600/*
4601 * FUNCTION: WDA_ProcessAddStaSelfReq
4602 *
4603 */
4604VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4605{
4606 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4607 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4608 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4609 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4610 sizeof(WDI_AddSTASelfReqParamsType)) ;
4611 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4612 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4613 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4614 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4615 if( NULL == wdiAddStaSelfReq )
4616 {
4617 VOS_ASSERT( 0 );
4618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4619 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4620 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4621 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4622 return( VOS_STATUS_E_NOMEM );
4623 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4624 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4625 if( NULL == pWdaParams )
4626 {
4627 VOS_ASSERT( 0 );
4628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4629 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4630 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4631 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4632 vos_mem_free(wdiAddStaSelfReq) ;
4633 return( VOS_STATUS_E_NOMEM );
4634 }
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4635 wdiAddStaSelfReq->wdiReqStatusCB = WDA_ProcessAddStaSelfReqCallback;
4636 wdiAddStaSelfReq->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4637 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4638 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4639 /* Store Init Req pointer, as this will be used for response */
4640 /* store Params pass it to WDI */
4641 pWdaParams->pWdaContext = pWDA;
4642 pWdaParams->wdaMsgParam = pAddStaSelfReq;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4643 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
4644
4645 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq,
4646 WDA_ProcessAddStaSelfRspCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4647
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4648 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4649 {
4650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4651 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4652 wstatus );
4653 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4654 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4655 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4656 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4657 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4658 pAddStaSelfReq->status = eSIR_FAILURE ;
4659 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4660 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4661 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4662}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4663/*
4664 * FUNCTION: WDA_DelSTASelfRespCallback
4665 *
4666 */
4667void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4668 wdiDelStaSelfRspParams , void* pUserData)
4669{
4670 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4671 tWDA_CbContext *pWDA;
4672 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4674 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4675 if (NULL == pWdaParams)
4676 {
4677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4678 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4679 VOS_ASSERT(0);
4680 return;
4681 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4682 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4683 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4684 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4685 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4686
4687 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4688 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4689 if (WDI_STATUS_SUCCESS != delStaSelfParams->status)
4690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4691 "%s: Failure with status %d", __func__,
4692 wdiDelStaSelfRspParams->wdiStatus);
4693 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4694 WLAN_LOG_INDICATOR_HOST_DRIVER,
4695 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4696 FALSE, TRUE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4697 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4698 return ;
4699}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4700/*
4701 * FUNCTION: WDA_DelSTASelfReqCallback
4702 *
4703 */
4704void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4705 void* pUserData)
4706{
4707 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4708 tWDA_CbContext *pWDA;
4709 tDelStaSelfParams *delStaSelfParams;
4710
4711 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4712 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4713 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714
4715 if (NULL == pWdaParams)
4716 {
4717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4718 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4719 VOS_ASSERT(0);
4720 return;
4721 }
4722
4723 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4724 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4725
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4726 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4727
4728 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4729 {
4730 VOS_ASSERT(0);
4731 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4732 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]4733 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4734 WLAN_LOG_INDICATOR_HOST_DRIVER,
4735 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4736 FALSE, TRUE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4737 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4738 }
4739
4740 return ;
4741}
4742
4743/*
4744 * FUNCTION: WDA_DelSTASelfReq
4745 * Trigger Config STA processing in WDI
4746 */
4747VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4748 tDelStaSelfParams* pDelStaSelfReqParam)
4749{
4750 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4751 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4752 tWDA_ReqParams *pWdaParams = NULL;
4753 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4754 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4755 sizeof(WDI_DelSTASelfReqParamsType)) ;
4756
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4758 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4759 if( NULL == wdiDelStaSelfReq )
4760 {
4761 VOS_ASSERT( 0 );
4762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4763 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4764 return( VOS_STATUS_E_NOMEM );
4765 }
4766
4767 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4768 if( NULL == pWdaParams )
4769 {
4770 VOS_ASSERT( 0 );
4771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4772 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4773 vos_mem_free(wdiDelStaSelfReq) ;
4774 return( VOS_STATUS_E_NOMEM );
4775 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4776 pWdaParams->pWdaContext = pWDA;
4777 /* Store param pointer as passed in by caller */
4778 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4779 /* store Params pass it to WDI */
4780 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4781 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4782 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4783
4784 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4785 wdiDelStaSelfReq->pUserData = pWdaParams;
4786
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4787 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4788 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4789
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4790 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4791 {
4792 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4793 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4794 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4795 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4796 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4797 vos_mem_free(pWdaParams) ;
4798 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4799 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4800 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4801 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4802}
4803
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4804/*
4805 * FUNCTION: WDA_SendMsg
4806 * Send Message back to PE
4807 */
4808void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4809 void *pBodyptr, tANI_U32 bodyVal)
4810{
4811 tSirMsgQ msg = {0} ;
4812 tANI_U32 status = VOS_STATUS_SUCCESS ;
4813 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4814 msg.type = msgType;
4815 msg.bodyval = bodyVal;
4816 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4817 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4818 if (VOS_STATUS_SUCCESS != status)
4819 {
4820 if(NULL != pBodyptr)
4821 {
4822 vos_mem_free(pBodyptr);
4823 }
4824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4825 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4826 VOS_ASSERT(0) ;
4827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4828 return ;
4829}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4830/*
4831 * FUNCTION: WDA_UpdateBSSParams
4832 * Translated WDA/PE BSS info into WDI BSS info..
4833 */
4834void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4835 WDI_ConfigBSSReqInfoType *wdiBssParams,
4836 tAddBssParams *wdaBssParams)
4837{
4838 v_U8_t keyIndex = 0;
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]4839 v_U8_t i = 0;
4840
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4841 /* copy bssReq Params to WDI structure */
4842 vos_mem_copy(wdiBssParams->macBSSID,
4843 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4844 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4845 sizeof(tSirMacAddr)) ;
4846 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4847 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4848 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849 wdiBssParams->ucShortSlotTimeSupported =
4850 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4851 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4852 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4853 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4854 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4855 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4856
4857 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4858 wdiBssParams->ucTXOPProtectionFullSupport =
4859 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4860 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4861 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4862 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4863 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4864 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4865 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4866 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4867
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4868 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4869
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4870 /* copy SSID into WDI structure */
4871 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4872 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4873 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4874 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4875 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4876 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4877#ifdef WLAN_FEATURE_VOWIFI
4878 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4879#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4880 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4881 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4882#ifdef WLAN_FEATURE_VOWIFI_11R
4883 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4884 if(wdiBssParams->bExtSetStaKeyParamValid)
4885 {
4886 /* copy set STA key params to WDI structure */
4887 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4888 wdaBssParams->extSetStaKeyParam.staIdx;
4889 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4890 wdaBssParams->extSetStaKeyParam.encType;
4891 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4892 wdaBssParams->extSetStaKeyParam.wepType;
4893 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4894 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4895 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4896 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4897 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4898 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4899 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4900 {
4901 WDA_GetWepKeysFromCfg( pWDA,
4902 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4903 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4904 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4905 }
4906 else
4907 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4908 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4909 keyIndex++)
4910 {
4911 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4912 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4913 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4914 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4915 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4916 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]4917
4918 if(WDA_getHostWlanFeatCaps(DISA) && WDA_getFwWlanFeatCaps(DISA))
4919 {
4920 for (i = 0; i < WLAN_MAX_KEY_RSC_LEN; i ++)
4921 {
4922 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc[i] =
4923 ~(wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc[i]);
4924 }
4925
4926 for (i = 0; i < SIR_MAC_MAX_KEY_LENGTH; i++)
4927 {
4928 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key[i] =
4929 ~(wdaBssParams->extSetStaKeyParam.key[keyIndex].key[i]);
4930 }
4931 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4932 FL("%s: Negated Keys"), __func__);
4933 }
4934 else
4935 {
4936 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4937 FL("%s: No change in Keys "), __func__);
4938 vos_mem_copy(
4939 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4940 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc,
4941 WLAN_MAX_KEY_RSC_LEN);
4942 vos_mem_copy(
4943 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4944 wdaBssParams->extSetStaKeyParam.key[keyIndex].key,
4945 SIR_MAC_MAX_KEY_LENGTH);
4946 }
4947
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4948 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4949 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4950 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4951 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4952 }
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]4953 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4954 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4955 }
4956 }
4957 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4958 }
4959 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4960 {
4961 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4962 sizeof(wdaBssParams->extSetStaKeyParam) );
4963 }
4964#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4965#ifdef WLAN_FEATURE_11AC
4966 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4967 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4968#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4969
4970 return ;
4971}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4972/*
4973 * FUNCTION: WDA_UpdateSTAParams
4974 * Translated WDA/PE BSS info into WDI BSS info..
4975 */
4976void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4977 WDI_ConfigStaReqInfoType *wdiStaParams,
4978 tAddStaParams *wdaStaParams)
4979{
4980 tANI_U8 i = 0;
4981 /* Update STA params */
4982 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4983 sizeof(tSirMacAddr)) ;
4984 wdiStaParams->usAssocId = wdaStaParams->assocId;
4985 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4986 wdiStaParams->staIdx = wdaStaParams->staIdx;
4987
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4988 wdiStaParams->ucShortPreambleSupported =
4989 wdaStaParams->shortPreambleSupported;
4990 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4991 sizeof(tSirMacAddr)) ;
4992 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4993
4994 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4995
4996 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4997 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4998 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4999 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
5000 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
5001 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
5002 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
5003
5004 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
5005 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5006 wdiStaParams->wdiSupportedRates.opRateMode =
5007 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5008 for(i = 0;i < WDI_NUM_11B_RATES;i++)
5009 {
5010 wdiStaParams->wdiSupportedRates.llbRates[i] =
5011 wdaStaParams->supportedRates.llbRates[i];
5012 }
5013 for(i = 0;i < WDI_NUM_11A_RATES;i++)
5014 {
5015 wdiStaParams->wdiSupportedRates.llaRates[i] =
5016 wdaStaParams->supportedRates.llaRates[i];
5017 }
5018 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
5019 {
5020 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
5021 wdaStaParams->supportedRates.aniLegacyRates[i];
5022 }
5023 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
5024 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5025#ifdef WLAN_FEATURE_11AC
5026 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
5027 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
5028 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
5029 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
5030#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5031 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
5032 {
5033 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
5034 wdaStaParams->supportedRates.supportedMCSSet[i];
5035 }
5036 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
5037 wdaStaParams->supportedRates.rxHighestDataRate;
5038
5039 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
5040
5041 wdiStaParams->wdiAction = wdaStaParams->updateSta;
5042
5043 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
5044 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
5045 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
5046
5047 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
5048 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
5049 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
5050 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5051 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5052#ifdef WLAN_FEATURE_11AC
5053 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
5054 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]5055 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]5056 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
5057 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
5058 * must be set by default */
5059 if ( wdiStaParams->vhtTxMUBformeeCapable )
5060 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5061#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]5062 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
5063 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5064 return ;
5065}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5066/*
5067 * -------------------------------------------------------------------------
5068 * CFG update to WDI
5069 * -------------------------------------------------------------------------
5070 */
5071
5072 /*
5073 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
5074 * Convert the WNI CFG ID to HAL CFG ID
5075 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5076static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5077{
5078 switch(wniCfgId)
5079 {
5080 case WNI_CFG_STA_ID:
5081 return QWLAN_HAL_CFG_STA_ID;
5082 case WNI_CFG_CURRENT_TX_ANTENNA:
5083 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
5084 case WNI_CFG_CURRENT_RX_ANTENNA:
5085 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
5086 case WNI_CFG_LOW_GAIN_OVERRIDE:
5087 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
5088 case WNI_CFG_POWER_STATE_PER_CHAIN:
5089 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
5090 case WNI_CFG_CAL_PERIOD:
5091 return QWLAN_HAL_CFG_CAL_PERIOD;
5092 case WNI_CFG_CAL_CONTROL:
5093 return QWLAN_HAL_CFG_CAL_CONTROL;
5094 case WNI_CFG_PROXIMITY:
5095 return QWLAN_HAL_CFG_PROXIMITY;
5096 case WNI_CFG_NETWORK_DENSITY:
5097 return QWLAN_HAL_CFG_NETWORK_DENSITY;
5098 case WNI_CFG_MAX_MEDIUM_TIME:
5099 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
5100 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
5101 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
5102 case WNI_CFG_RTS_THRESHOLD:
5103 return QWLAN_HAL_CFG_RTS_THRESHOLD;
5104 case WNI_CFG_SHORT_RETRY_LIMIT:
5105 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
5106 case WNI_CFG_LONG_RETRY_LIMIT:
5107 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
5108 case WNI_CFG_FRAGMENTATION_THRESHOLD:
5109 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
5110 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
5111 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
5112 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
5113 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
5114 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
5115 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
5116 case WNI_CFG_FIXED_RATE:
5117 return QWLAN_HAL_CFG_FIXED_RATE;
5118 case WNI_CFG_RETRYRATE_POLICY:
5119 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
5120 case WNI_CFG_RETRYRATE_SECONDARY:
5121 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
5122 case WNI_CFG_RETRYRATE_TERTIARY:
5123 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
5124 case WNI_CFG_FORCE_POLICY_PROTECTION:
5125 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
5126 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
5127 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
5128 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
5129 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
5130 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
5131 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
5132 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
5133 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
5134 case WNI_CFG_MAX_BA_SESSIONS:
5135 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
5136 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
5137 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
5138 case WNI_CFG_PS_ENABLE_BCN_FILTER:
5139 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
5140 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
5141 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
5142 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
5143 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
5144 case WNI_CFG_STATS_PERIOD:
5145 return QWLAN_HAL_CFG_STATS_PERIOD;
5146 case WNI_CFG_CFP_MAX_DURATION:
5147 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
5148#if 0 /*This is not part of CFG*/
5149 case WNI_CFG_FRAME_TRANS_ENABLED:
5150 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
5151#endif
5152 case WNI_CFG_DTIM_PERIOD:
5153 return QWLAN_HAL_CFG_DTIM_PERIOD;
5154 case WNI_CFG_EDCA_WME_ACBK:
5155 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
5156 case WNI_CFG_EDCA_WME_ACBE:
5157 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
5158 case WNI_CFG_EDCA_WME_ACVI:
5159 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
5160 case WNI_CFG_EDCA_WME_ACVO:
5161 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
5162#if 0
5163 case WNI_CFG_TELE_BCN_WAKEUP_EN:
5164 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
5165 case WNI_CFG_TELE_BCN_TRANS_LI:
5166 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
5167 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
5168 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
5169 case WNI_CFG_TELE_BCN_MAX_LI:
5170 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
5171 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
5172 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
5173#endif
5174 case WNI_CFG_ENABLE_CLOSE_LOOP:
5175 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]5176 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
5177 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
jagadeeshaf2d0ce2015-03-31 11:45:30 +0530[diff] [blame]5178 case WNI_CFG_ENABLE_RTSCTS_HTVHT:
5179 return QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5180 default:
5181 {
5182 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5183 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5184 wniCfgId);
5185 return VOS_STATUS_E_INVAL;
5186 }
5187 }
5188}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5189/*
5190 * FUNCTION: WDA_UpdateCfgCallback
5191 *
5192 */
5193void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
5194{
5195 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5196 WDI_UpdateCfgReqParamsType *wdiCfgParam =
5197 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5199 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5200 /*
5201 * currently there is no response message is expected between PE and
5202 * WDA, Failure return from WDI is a ASSERT condition
5203 */
5204 if(WDI_STATUS_SUCCESS != wdiStatus)
5205 {
5206 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5207 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5208 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
5209 }
5210
5211 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
5212 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5213 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5214 return ;
5215}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5216/*
5217 * FUNCTION: WDA_UpdateCfg
5218 *
5219 */
5220VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
5221{
5222
5223 WDI_Status status = WDI_STATUS_SUCCESS ;
5224 tANI_U32 val =0;
5225 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
5226 tHalCfg *configData;
5227 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
5228 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5230 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5231 if (NULL == pMac )
5232 {
5233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5234 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5235 return VOS_STATUS_E_FAILURE;
5236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5237 if(WDA_START_STATE != pWDA->wdaState)
5238 {
5239 return VOS_STATUS_E_FAILURE;
5240 }
5241
5242 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
5243 {
5244 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5245 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5246 VOS_ASSERT(0);
5247 return VOS_STATUS_E_FAILURE;
5248 }
5249
5250 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
5251 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5252 if(NULL == wdiCfgReqParam)
5253 {
5254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5255 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5256 VOS_ASSERT(0);
5257 return VOS_STATUS_E_NOMEM;
5258 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5259 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
5260 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5261 if(NULL == wdiCfgReqParam->pConfigBuffer)
5262 {
5263 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5264 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5265 vos_mem_free(wdiCfgReqParam);
5266 VOS_ASSERT(0);
5267 return VOS_STATUS_E_NOMEM;
5268 }
5269
5270 /*convert the WNI CFG Id to HAL CFG Id*/
5271 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
5272 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
5273
5274 /*TODO: revisit this for handling string parameters */
5275 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
5276 &val) != eSIR_SUCCESS)
5277 {
5278 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5279 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5280 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
5281 vos_mem_free(wdiCfgReqParam);
5282 return eSIR_FAILURE;
5283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5284 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
5285 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
5286 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
5287 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
5288 wdiCfgReqParam->wdiReqStatusCB = NULL ;
5289
5290 /* store Params pass it to WDI */
5291 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5292#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
5293 status = WDI_UpdateCfgReq(wdiCfgReqParam,
5294 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5295 if(IS_WDI_STATUS_FAILURE(status))
5296 {
5297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5298 "Failure in Update CFG WDI API, free all the memory " );
5299 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
5300 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5301 pWDA->wdaWdiCfgApiMsgParam = NULL;
5302 /* Failure is not expected */
5303 VOS_ASSERT(0) ;
5304 }
5305#else
5306 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
5307 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5308 pWDA->wdaWdiCfgApiMsgParam = NULL;
5309#endif
5310 return CONVERT_WDI2VOS_STATUS(status) ;
5311}
5312
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5313VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
5314 v_U8_t *pDefaultKeyId,
5315 v_U8_t *pNumKeys,
5316 WDI_KeysType *pWdiKeys )
5317{
5318 v_U32_t i, j, defKeyId = 0;
5319 v_U32_t val = SIR_MAC_KEY_LENGTH;
5320 VOS_STATUS status = WDI_STATUS_SUCCESS;
5321 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5322 if (NULL == pMac )
5323 {
5324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5325 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5326 return VOS_STATUS_E_FAILURE;
5327 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5328 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
5329 &defKeyId ))
5330 {
5331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5332 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
5333 }
5334
5335 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5336 /* Need to extract ALL of the configured WEP Keys */
5337 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
5338 {
5339 val = SIR_MAC_KEY_LENGTH;
5340 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
5341 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
5342 pWdiKeys[j].key,
5343 &val ))
5344 {
5345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5346 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5347 }
5348 else
5349 {
5350 pWdiKeys[j].keyId = (tANI_U8) i;
5351 /*
5352 * Actually, a DC (Don't Care) because
5353 * this is determined (and set) by PE/MLME
5354 */
5355 pWdiKeys[j].unicast = 0;
5356 /*
5357 * Another DC (Don't Care)
5358 */
5359 pWdiKeys[j].keyDirection = eSIR_TX_RX;
5360 /* Another DC (Don't Care). Unused for WEP */
5361 pWdiKeys[j].paeRole = 0;
5362 /* Determined from wlan_cfgGetStr() above.*/
5363 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5364 j++;
5365 *pNumKeys = (tANI_U8) j;
5366 }
5367 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5368 return status;
5369}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5370/*
5371 * FUNCTION: WDA_SetBssKeyReqCallback
5372 * send SET BSS key RSP back to PE
5373 */
5374void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
5375{
5376 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5377 tWDA_CbContext *pWDA;
5378 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5380 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5381 if(NULL == pWdaParams)
5382 {
5383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5384 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5385 VOS_ASSERT(0) ;
5386 return ;
5387 }
5388 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5389 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]5390 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
5391 sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5392 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5393 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5394 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5395 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5396 return ;
5397}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5398/*
5399 * FUNCTION: WDA_ProcessSetBssKeyReq
5400 * Request to WDI for programming the BSS key( key for
5401 * broadcast/multicast frames Encryption)
5402 */
5403VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
5404 tSetBssKeyParams *setBssKeyParams )
5405{
5406 WDI_Status status = WDI_STATUS_SUCCESS ;
5407 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
5408 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
5409 sizeof(WDI_SetBSSKeyReqParamsType)) ;
5410 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5411 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5413 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5414 if(NULL == wdiSetBssKeyParam)
5415 {
5416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5417 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5418 VOS_ASSERT(0);
5419 return VOS_STATUS_E_NOMEM;
5420 }
5421 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5422 if(NULL == pWdaParams)
5423 {
5424 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5425 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5426 VOS_ASSERT(0);
5427 vos_mem_free(wdiSetBssKeyParam);
5428 return VOS_STATUS_E_NOMEM;
5429 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5430 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5431 /* copy set BSS params to WDI structure */
5432 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
5433 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
5434 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5435 if(setBssKeyParams->encType != eSIR_ED_NONE)
5436 {
5437 if( setBssKeyParams->numKeys == 0 &&
5438 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
5439 setBssKeyParams->encType == eSIR_ED_WEP104))
5440 {
5441 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5442 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
5443 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
5444 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
5445 }
5446 else
5447 {
5448 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
5449 {
5450 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
5451 setBssKeyParams->key[keyIndex].keyId;
5452 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
5453 setBssKeyParams->key[keyIndex].unicast;
5454 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
5455 setBssKeyParams->key[keyIndex].keyDirection;
5456 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
5457 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5458 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
5459 setBssKeyParams->key[keyIndex].paeRole;
5460 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
5461 setBssKeyParams->key[keyIndex].keyLength;
5462 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
5463 setBssKeyParams->key[keyIndex].key,
5464 SIR_MAC_MAX_KEY_LENGTH);
5465 }
5466 }
5467 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5468 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
5469 setBssKeyParams->singleTidRc;
5470 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5471 /* Store set key pointer, as this will be used for response */
5472 /* store Params pass it to WDI */
5473 pWdaParams->pWdaContext = pWDA;
5474 pWdaParams->wdaMsgParam = setBssKeyParams;
5475 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5476 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
5477 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
5478
5479 if(IS_WDI_STATUS_FAILURE(status))
5480 {
5481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5482 "Failure in Set BSS Key Req WDI API, free all the memory " );
5483 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5484 vos_mem_free(pWdaParams) ;
5485 setBssKeyParams->status = eSIR_FAILURE ;
5486 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
5487 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5488 return CONVERT_WDI2VOS_STATUS(status) ;
5489}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5490/*
5491 * FUNCTION: WDA_RemoveBssKeyReqCallback
5492 * send SET BSS key RSP back to PE
5493 */
5494void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
5495{
5496 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5497 tWDA_CbContext *pWDA;
5498 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5500 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5501 if(NULL == pWdaParams)
5502 {
5503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5504 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5505 VOS_ASSERT(0) ;
5506 return ;
5507 }
5508 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5509 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5510 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5511 vos_mem_free(pWdaParams) ;
5512
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5513 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5514 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5515 return ;
5516}
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5517
5518/*
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5519 * FUNCTION: WDA_GetFrameLogRspCallback
5520 * recieves get frame log response from FW
5521 */
5522void WDA_GetFrameLogRspCallback(WDI_GetFrameLogRspParamType* wdiRsp,
5523 void* pUserData)
5524{
5525 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5526 tWDA_CbContext *pWDA = NULL;
5527 tAniGetFrameLogReq *pGetFrameLogReqParams = NULL;
5528
5529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5530 "<------ Entering: %s " ,__func__);
5531 if(NULL == pWdaParams)
5532 {
5533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5534 "%s: pWdaParams received NULL", __func__);
5535 VOS_ASSERT(0) ;
5536 return ;
5537 }
5538
5539 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
5540 if (NULL == pWDA)
5541 {
5542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5543 "%s:pWDA is NULL", __func__);
5544 VOS_ASSERT(0);
5545 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5546 vos_mem_free(pWdaParams);
5547 return ;
5548 }
5549
5550 pGetFrameLogReqParams = (tAniGetFrameLogReq *)pWdaParams->wdaMsgParam;
5551 if(NULL == pGetFrameLogReqParams)
5552 {
5553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5554 "%s: pGetFrameLogReqParams received NULL", __func__);
5555 VOS_ASSERT(0);
5556 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5557 vos_mem_free(pWdaParams);
5558 return;
5559 }
5560
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5561 if (wdiRsp->wdiStatus != WDI_STATUS_SUCCESS) {
5562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Abhishek Singh611295e2015-07-09 11:11:54 +0530[diff] [blame]5563 "%s:GetFrameLog with rsp status %d flag %d", __func__,
5564 wdiRsp->wdiStatus,pGetFrameLogReqParams->getFrameLogCmdFlag);
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5565 }
5566
5567 /* free WDI command buffer only */
5568 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5569 vos_mem_free(pWdaParams->wdaMsgParam);
5570 vos_mem_free(pWdaParams);
5571
5572 return ;
5573
5574}
5575/*
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5576 * FUNCTION: WDA_FWLoggingInitRspCallback
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5577 * recieves Mgmt Logging init response from FW
5578 */
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5579void WDA_FWLoggingInitRspCallback(WDI_FWLoggingInitRspParamType* wdiRsp,
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5580 void* pUserData)
5581{
5582 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5583 tSirFWLoggingInitParam *pFWLoggingInitParams;
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5584 tAniLoggingInitRsp *pLoggingInitRsp;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5585
5586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5587 "<------ %s " ,__func__);
5588
5589 if(NULL == pWdaParams)
5590 {
5591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5592 "%s: pWdaParams received NULL", __func__);
5593 VOS_ASSERT(0);
5594 return ;
5595 }
5596
5597 if(NULL == pWdaParams->wdaMsgParam)
5598 {
5599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5600 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
5601 VOS_ASSERT(0);
5602 vos_mem_free(pWdaParams);
5603 return ;
5604 }
5605
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5606 pLoggingInitRsp = (tAniLoggingInitRsp *)vos_mem_malloc(sizeof(tAniLoggingInitRsp)) ;
5607 if(NULL == pWdaParams)
5608 {
5609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5610 "%s: VOS MEM Alloc Failure for pLoggingInitRsp", __func__);
5611 VOS_ASSERT(0);
5612 vos_mem_free(pWdaParams);
5613 return;
5614 }
5615
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5616 pFWLoggingInitParams = (tSirFWLoggingInitParam *)pWdaParams->wdaMsgParam;
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5617 vos_mem_copy(pLoggingInitRsp, wdiRsp, sizeof(tAniLoggingInitRsp));
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5618
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5619 if(pFWLoggingInitParams->fwlogInitCallback)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5620 {
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5621 pFWLoggingInitParams->fwlogInitCallback(
5622 pFWLoggingInitParams->fwlogInitCbContext,
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5623 pLoggingInitRsp);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5624 }
5625 else
5626 {
5627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5628 "%s: pFWLoggingInitParams callback is NULL", __func__);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5629 }
5630
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5631 vos_mem_free(pLoggingInitRsp);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5632 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5633 vos_mem_free(pWdaParams->wdaMsgParam);
5634 vos_mem_free(pWdaParams);
5635
5636 return;
5637}
5638
5639/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5640 * FUNCTION: WDA_SpoofMacAddrRspCallback
5641 * recieves spoof mac addr response from FW
5642 */
5643void WDA_SpoofMacAddrRspCallback(WDI_SpoofMacAddrRspParamType* wdiRsp, void* pUserData)
5644{
5645 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5646 tWDA_CbContext *pWDA;
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5647
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5649 "<------ %s " ,__func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5650
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5651 if(NULL == pWdaParams)
5652 {
5653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5654 "%s: pWdaParams received NULL", __func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5655 VOS_ASSERT(0);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5656 return ;
5657 }
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5658 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5659
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5660 if (wdiRsp->wdiStatus != WDI_STATUS_SUCCESS) {
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5662 "%s:Spoofing with rsp status %d", __func__, wdiRsp->wdiStatus);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5663 }
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5664 WDA_SendMsg(pWDA, WDA_SPOOF_MAC_ADDR_RSP, NULL,
5665 CONVERT_WDI2SIR_STATUS(wdiRsp->wdiStatus));
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5666
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5667 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5668 vos_mem_free(pWdaParams->wdaMsgParam);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5669 vos_mem_free(pWdaParams);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5670
5671 return;
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5672}
5673
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5674/*
5675 * FUNCTION: WDA_ProcessRemoveBssKeyReq
5676 * Request to WDI to remove the BSS key( key for broadcast/multicast
5677 * frames Encryption)
5678 */
5679VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
5680 tRemoveBssKeyParams *removeBssKeyParams )
5681{
5682 WDI_Status status = WDI_STATUS_SUCCESS ;
5683 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
5684 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
5685 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
5686 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5688 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5689 if(NULL == wdiRemoveBssKeyParam)
5690 {
5691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5692 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5693 VOS_ASSERT(0);
5694 return VOS_STATUS_E_NOMEM;
5695 }
5696 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5697 if(NULL == pWdaParams)
5698 {
5699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5700 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5701 VOS_ASSERT(0);
5702 vos_mem_free(wdiRemoveBssKeyParam);
5703 return VOS_STATUS_E_NOMEM;
5704 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5705 /* copy Remove BSS key params to WDI structure*/
5706 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5707 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5708 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5709 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5710 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5711 /* Store remove key pointer, as this will be used for response */
5712 /* store Params pass it to WDI */
5713 pWdaParams->pWdaContext = pWDA;
5714 pWdaParams->wdaMsgParam = removeBssKeyParams;
5715 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5716 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5717 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5718 if(IS_WDI_STATUS_FAILURE(status))
5719 {
5720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5721 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5723 vos_mem_free(pWdaParams) ;
5724 removeBssKeyParams->status = eSIR_FAILURE ;
5725 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5727 return CONVERT_WDI2VOS_STATUS(status) ;
5728}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5729/*
5730 * FUNCTION: WDA_SetBssKeyReqCallback
5731 * send SET BSS key RSP back to PE
5732 */
5733void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5734{
5735 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5736 tWDA_CbContext *pWDA;
5737 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5738 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5739 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5740 if(NULL == pWdaParams)
5741 {
5742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5743 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5744 VOS_ASSERT(0) ;
5745 return ;
5746 }
5747 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5748 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]5749 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
5750 sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5751 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5752 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5753 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5754 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5755 return ;
5756}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5757/*
5758 * FUNCTION: WDA_ProcessSetStaKeyReq
5759 * Request to WDI for programming the STA key( key for Unicast frames
5760 * Encryption)
5761 */
5762VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5763 tSetStaKeyParams *setStaKeyParams )
5764{
5765 WDI_Status status = WDI_STATUS_SUCCESS ;
5766 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5767 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5768 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5769 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5770 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5772 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5773 if(NULL == wdiSetStaKeyParam)
5774 {
5775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5776 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5777 VOS_ASSERT(0);
5778 return VOS_STATUS_E_NOMEM;
5779 }
5780 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5781 if(NULL == pWdaParams)
5782 {
5783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5784 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5785 VOS_ASSERT(0);
5786 vos_mem_free(wdiSetStaKeyParam);
5787 return VOS_STATUS_E_NOMEM;
5788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5789 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5790 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5791 /* copy set STA key params to WDI structure */
5792 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5793 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5794 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5795 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5796 if(setStaKeyParams->encType != eSIR_ED_NONE)
5797 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5798 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5799 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5800 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5801 {
5802 WDA_GetWepKeysFromCfg( pWDA,
5803 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5804 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5805 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5806 }
5807 else
5808 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5809 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5810 keyIndex++)
5811 {
5812 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5813 setStaKeyParams->key[keyIndex].keyId;
5814 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5815 setStaKeyParams->key[keyIndex].unicast;
5816 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5817 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5818 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5819 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5820 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5821 setStaKeyParams->key[keyIndex].paeRole;
5822 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5823 setStaKeyParams->key[keyIndex].keyLength;
5824 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5825 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5826 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5827 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5828 {
5829 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5830 }
5831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5832 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5833 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5834 }
5835 }
5836 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5837 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5838 /* Store set key pointer, as this will be used for response */
5839 /* store Params pass it to WDI */
5840 pWdaParams->pWdaContext = pWDA;
5841 pWdaParams->wdaMsgParam = setStaKeyParams;
5842 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5843 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5844 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5845 if(IS_WDI_STATUS_FAILURE(status))
5846 {
5847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5848 "Failure in set STA Key Req WDI API, free all the memory " );
5849 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5850 vos_mem_free(pWdaParams) ;
5851 setStaKeyParams->status = eSIR_FAILURE ;
5852 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5854 return CONVERT_WDI2VOS_STATUS(status) ;
5855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5856/*
5857 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5858 * send SET Bcast STA key RSP back to PE
5859 */
5860void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5861{
5862 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5863 tWDA_CbContext *pWDA;
5864 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5866 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5867 if(NULL == pWdaParams)
5868 {
5869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5870 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5871 VOS_ASSERT(0) ;
5872 return ;
5873 }
5874 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5875 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5876 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5877 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5878 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5879 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5880 return ;
5881}
5882
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5883/*
5884 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5885 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5886 * Encryption)
5887 */
5888VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5889 tSetStaKeyParams *setStaKeyParams )
5890{
5891 WDI_Status status = WDI_STATUS_SUCCESS ;
5892 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5893 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5894 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5895 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5896 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5898 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5899 if(NULL == wdiSetStaKeyParam)
5900 {
5901 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5902 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5903 VOS_ASSERT(0);
5904 return VOS_STATUS_E_NOMEM;
5905 }
5906 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5907 if(NULL == pWdaParams)
5908 {
5909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5910 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5911 VOS_ASSERT(0);
5912 vos_mem_free(wdiSetStaKeyParam);
5913 return VOS_STATUS_E_NOMEM;
5914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5915 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5917 /* copy set STA key params to WDI structure */
5918 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5919 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5920 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5921 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5922 if(setStaKeyParams->encType != eSIR_ED_NONE)
5923 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5924 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5925 keyIndex++)
5926 {
5927 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5928 setStaKeyParams->key[keyIndex].keyId;
5929 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5930 setStaKeyParams->key[keyIndex].unicast;
5931 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5932 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5933 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5934 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5935 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5936 setStaKeyParams->key[keyIndex].paeRole;
5937 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5938 setStaKeyParams->key[keyIndex].keyLength;
5939 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5940 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5941 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5942 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5943 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5944 }
5945 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946 /* Store set key pointer, as this will be used for response */
5947 /* store Params pass it to WDI */
5948 pWdaParams->pWdaContext = pWDA;
5949 pWdaParams->wdaMsgParam = setStaKeyParams;
5950 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5951 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5952 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5953 if(IS_WDI_STATUS_FAILURE(status))
5954 {
5955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5956 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5957 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5958 vos_mem_free(pWdaParams) ;
5959 setStaKeyParams->status = eSIR_FAILURE ;
5960 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5961 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5962 return CONVERT_WDI2VOS_STATUS(status) ;
5963}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5964/*
5965 * FUNCTION: WDA_RemoveStaKeyReqCallback
5966 * send SET BSS key RSP back to PE
5967 */
5968void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5969{
5970 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5971 tWDA_CbContext *pWDA;
5972 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5974 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5975 if(NULL == pWdaParams)
5976 {
5977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5978 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5979 VOS_ASSERT(0) ;
5980 return ;
5981 }
5982 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5983 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5984 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5985 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5986 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5987 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5988 return ;
5989}
5990
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5991/*
5992 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5993 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5994 */
5995VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5996 tRemoveStaKeyParams *removeStaKeyParams )
5997{
5998 WDI_Status status = WDI_STATUS_SUCCESS ;
5999 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
6000 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
6001 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
6002 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6004 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6005 if(NULL == wdiRemoveStaKeyParam)
6006 {
6007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6008 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6009 VOS_ASSERT(0);
6010 return VOS_STATUS_E_NOMEM;
6011 }
6012 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6013 if(NULL == pWdaParams)
6014 {
6015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6016 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6017 VOS_ASSERT(0);
6018 vos_mem_free(wdiRemoveStaKeyParam);
6019 return VOS_STATUS_E_NOMEM;
6020 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6021 /* copy remove STA key params to WDI structure*/
6022 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
6023 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
6024 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
6025 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
6026 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6027 /* Store remove key pointer, as this will be used for response */
6028 /* store Params pass it to WDI */
6029 pWdaParams->pWdaContext = pWDA;
6030 pWdaParams->wdaMsgParam = removeStaKeyParams;
6031 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6032 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
6033 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6034 if(IS_WDI_STATUS_FAILURE(status))
6035 {
6036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6037 "Failure in remove STA Key Req WDI API, free all the memory " );
6038 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6039 vos_mem_free(pWdaParams) ;
6040 removeStaKeyParams->status = eSIR_FAILURE ;
6041 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
6042 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6043 return CONVERT_WDI2VOS_STATUS(status) ;
6044}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6045/*
6046 * FUNCTION: WDA_IsHandleSetLinkStateReq
6047 * Update the WDA state and return the status to handle this message or not
6048 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6049WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
6050 tWDA_CbContext *pWDA,
6051 tLinkStateParams *linkStateParams)
6052{
6053 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6054 switch(linkStateParams->state)
6055 {
6056 case eSIR_LINK_PREASSOC_STATE:
6057 case eSIR_LINK_BTAMP_PREASSOC_STATE:
6058 /*
6059 * set the WDA state to PRE ASSOC
6060 * copy the BSSID into pWDA to use it in join request and return,
6061 * No need to handle these messages.
6062 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6063 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
6064 {
6065 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6066 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6067 }
6068 else
6069 {
6070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6071 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6072 VOS_ASSERT(0);
6073 }
6074
6075 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
6076 {
6077 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6078 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6079 }
6080 else
6081 {
6082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6083 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6084 VOS_ASSERT(0);
6085 }
6086
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6087 /* UMAC is issuing the setlink state with PREASSOC twice (before set
6088 *channel and after ) so reset the WDA state to ready when the second
6089 * time UMAC issue the link state with PREASSOC
6090 */
6091 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
6092 {
6093 /* RESET WDA state back to WDA_READY_STATE */
6094 pWDA->wdaState = WDA_READY_STATE;
6095 }
6096 else
6097 {
6098 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
6099 }
6100 //populate linkState info in WDACbCtxt
6101 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6102 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6103 default:
6104 if(pWDA->wdaState != WDA_READY_STATE)
6105 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6106 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
6107 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
6108 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
6109 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
6110 *the ASSERT in WDA_Stop during module unload.*/
6111 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
6112 {
6113 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6114 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6115 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6116 else
6117 {
6118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6119 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6120 status = WDA_IGNORE_SET_LINK_STATE;
6121 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6122 }
6123 break;
6124 }
6125
6126 return status;
6127}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6128/*
6129 * FUNCTION: WDA_SetLinkStateCallback
6130 * call back function for set link state from WDI
6131 */
6132void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
6133{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6134 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6135 tLinkStateParams *linkStateParams;
6136 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6138 "<------ %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6139 if (NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6140 {
6141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6142 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6143 VOS_ASSERT(0) ;
6144 return ;
6145 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6146 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6147 if (NULL == pWDA)
6148 {
6149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6150 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6152 vos_mem_free(pWdaParams->wdaMsgParam);
6153 vos_mem_free(pWdaParams);
6154
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6155 VOS_ASSERT(0);
6156 return ;
6157 }
6158
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6159 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6160 /*
6161 * In STA mode start the BA activity check timer after association
6162 * and in AP mode start BA activity check timer after BSS start */
6163 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
6164 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]6165 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
6166 ((status == WDI_STATUS_SUCCESS) &&
6167 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6168 {
6169 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
6170 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6171 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6172 /*
6173 * No respone required for WDA_SET_LINK_STATE so free the request
6174 * param here
6175 */
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6176 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6177 vos_mem_free(pWdaParams);
6178
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6179 return ;
6180}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6181/*
6182 * FUNCTION: WDA_ProcessSetLinkState
6183 * Request to WDI to set the link status.
6184 */
6185VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
6186 tLinkStateParams *linkStateParams)
6187{
6188 WDI_Status status = WDI_STATUS_SUCCESS ;
6189 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
6190 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
6191 sizeof(WDI_SetLinkReqParamsType)) ;
6192 tWDA_ReqParams *pWdaParams ;
6193 tpAniSirGlobal pMac;
6194 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
6195
6196 if(NULL == pMac)
6197 {
6198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6199 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6200 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6201 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6202 return VOS_STATUS_E_FAILURE;
6203 }
6204
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 == wdiSetLinkStateParam)
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(wdiSetLinkStateParam);
6221 return VOS_STATUS_E_NOMEM;
6222 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6223 if(WDA_IGNORE_SET_LINK_STATE ==
6224 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
6225 {
6226 status = WDI_STATUS_E_FAILURE;
6227 }
6228 else
6229 {
6230 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
6231 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6232 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
6233 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6234 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
6235 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6236 pWdaParams->pWdaContext = pWDA;
6237 /* Store remove key pointer, as this will be used for response */
6238 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6239 /* store Params pass it to WDI */
6240 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
6241 /* Stop Timer only other than GO role and concurrent session */
6242 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]6243 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6244 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
6245 {
6246 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
6247 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6248 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
6249 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6250 if(IS_WDI_STATUS_FAILURE(status))
6251 {
6252 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6253 "Failure in set link state Req WDI API, free all the memory " );
6254 }
6255 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6256 if(IS_WDI_STATUS_FAILURE(status))
6257 {
6258 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6259 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6260 vos_mem_free(pWdaParams);
6261 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6262 return CONVERT_WDI2VOS_STATUS(status) ;
6263}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6264/*
6265 * FUNCTION: WDA_GetStatsReqParamsCallback
6266 * send the response to PE with Stats received from WDI
6267 */
6268void WDA_GetStatsReqParamsCallback(
6269 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
6270 void* pUserData)
6271{
6272 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
6273 tAniGetPEStatsRsp *pGetPEStatsRspParams;
6274
6275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6276 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6277 pGetPEStatsRspParams =
6278 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
6279 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
6280
6281 if(NULL == pGetPEStatsRspParams)
6282 {
6283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6284 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6285 VOS_ASSERT(0);
6286 return;
6287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6288 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
6289 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
6290 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
6291 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6292
6293 //Fill the Session Id Properly in PE
6294 pGetPEStatsRspParams->sessionId = 0;
6295 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6296 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6297 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
6298 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6299 vos_mem_copy( pGetPEStatsRspParams + 1,
6300 wdiGetStatsRsp + 1,
6301 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6302 /* send response to UMAC*/
6303 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
6304
6305 return;
6306}
6307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6308/*
6309 * FUNCTION: WDA_ProcessGetStatsReq
6310 * Request to WDI to get the statistics
6311 */
6312VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
6313 tAniGetPEStatsReq *pGetStatsParams)
6314{
6315 WDI_Status status = WDI_STATUS_SUCCESS ;
6316 WDI_GetStatsReqParamsType wdiGetStatsParam;
6317 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6319 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6320 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
6321 pGetStatsParams->staId;
6322 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
6323 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6324 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6325 status = WDI_GetStatsReq(&wdiGetStatsParam,
6326 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6327 if(IS_WDI_STATUS_FAILURE(status))
6328 {
6329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6330 "Failure in Get Stats Req WDI API, free all the memory " );
6331 pGetPEStatsRspParams =
6332 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
6333 if(NULL == pGetPEStatsRspParams)
6334 {
6335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6336 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6337 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6338 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6339 return VOS_STATUS_E_NOMEM;
6340 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6341 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
6342 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
6343 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
6344 pGetPEStatsRspParams->rc = eSIR_FAILURE;
6345 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
6346 (void *)pGetPEStatsRspParams, 0) ;
6347 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6348 /* Free the request message */
6349 vos_mem_free(pGetStatsParams);
6350 return CONVERT_WDI2VOS_STATUS(status);
6351}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6352
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6353#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6354/*
6355 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
6356 * send the response to PE with roam Rssi received from WDI
6357 */
6358void WDA_GetRoamRssiReqParamsCallback(
6359 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
6360 void* pUserData)
6361{
6362 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6363 tWDA_CbContext *pWDA = NULL;
6364 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
6365 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
6366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6367 "<------ %s " ,__func__);
6368 if(NULL == pWdaParams)
6369 {
6370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6371 "%s: pWdaParams received NULL", __func__);
6372 VOS_ASSERT(0) ;
6373 return ;
6374 }
6375 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6376 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
6377
6378 if(NULL == pGetRoamRssiReqParams)
6379 {
6380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6381 "%s: pGetRoamRssiReqParams received NULL", __func__);
6382 VOS_ASSERT(0);
6383 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6384 vos_mem_free(pWdaParams);
6385 return ;
6386 }
6387 pGetRoamRssiRspParams =
6388 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
6389
6390 if(NULL == pGetRoamRssiRspParams)
6391 {
6392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6393 "%s: VOS MEM Alloc Failure", __func__);
6394 VOS_ASSERT(0);
6395 return;
6396 }
6397 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
6398 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6399 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6400 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
6401 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
6402
6403 /* Assign get roam rssi req (backup) in to the response */
6404 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
6405
6406 /* free WDI command buffer */
6407 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6408 vos_mem_free(pWdaParams) ;
6409
6410 /* send response to UMAC*/
6411 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
6412
6413 return;
6414}
6415
6416
6417
6418/*
6419 * FUNCTION: WDA_ProcessGetRoamRssiReq
6420 * Request to WDI to get the statistics
6421 */
6422VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
6423 tAniGetRssiReq *pGetRoamRssiParams)
6424{
6425 WDI_Status status = WDI_STATUS_SUCCESS ;
6426 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
6427 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
6428 tWDA_ReqParams *pWdaParams = NULL;
6429
6430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6431 "------> %s " ,__func__);
6432 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
6433 pGetRoamRssiParams->staId;
6434 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
6435
6436 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6437 if(NULL == pWdaParams)
6438 {
6439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6440 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]6441 vos_mem_free(pGetRoamRssiParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6442 VOS_ASSERT(0);
6443 return VOS_STATUS_E_NOMEM;
6444 }
6445
6446 /* Store Init Req pointer, as this will be used for response */
6447 pWdaParams->pWdaContext = pWDA;
6448
6449 /* Take Get roam Rssi req backup as it stores the callback to be called after
6450 receiving the response */
6451 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
6452 pWdaParams->wdaWdiApiMsgParam = NULL;
6453
6454 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
6455 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
6456 if(IS_WDI_STATUS_FAILURE(status))
6457 {
6458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6459 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
6460 pGetRoamRssiRspParams =
6461 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
6462 if(NULL == pGetRoamRssiRspParams)
6463 {
6464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6465 "%s: VOS MEM Alloc Failure", __func__);
6466 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]6467 vos_mem_free(pGetRoamRssiParams);
6468 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6469 return VOS_STATUS_E_NOMEM;
6470 }
6471 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
6472 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
6473 pGetRoamRssiRspParams->rssi = 0;
6474 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
6475 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
6476 (void *)pGetRoamRssiRspParams, 0) ;
6477 }
6478 return CONVERT_WDI2VOS_STATUS(status);
6479}
6480#endif
6481
6482
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6483/*
6484 * FUNCTION: WDA_UpdateEDCAParamCallback
6485 * call back function for Update EDCA params from WDI
6486 */
6487void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
6488{
6489 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6490 tEdcaParams *pEdcaParams;
6491
6492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6493 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6494 if(NULL == pWdaParams)
6495 {
6496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6497 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6498 VOS_ASSERT(0) ;
6499 return ;
6500 }
6501 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6502 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6503 vos_mem_free(pWdaParams);
6504 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6505 return ;
6506}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6507/*
6508 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
6509 * Request to WDI to Update the EDCA params.
6510 */
6511VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
6512 tEdcaParams *pEdcaParams)
6513{
6514 WDI_Status status = WDI_STATUS_SUCCESS ;
6515 WDI_UpdateEDCAParamsType *wdiEdcaParam =
6516 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
6517 sizeof(WDI_UpdateEDCAParamsType)) ;
6518 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6520 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6521 if(NULL == wdiEdcaParam)
6522 {
6523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6524 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6525 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6526 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6527 return VOS_STATUS_E_NOMEM;
6528 }
6529 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6530 if(NULL == pWdaParams)
6531 {
6532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6533 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6534 VOS_ASSERT(0);
6535 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6536 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6537 return VOS_STATUS_E_NOMEM;
6538 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6539 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]6540 /*
6541 Since firmware is not using highperformance flag, we have removed
6542 this flag from wdiEDCAInfo structure to match sizeof the structure
6543 between host and firmware.In future if we are planning to use
6544 highperformance flag then Please define this flag in wdiEDCAInfo
6545 structure, update it here and send it to firmware. i.e.
6546 Following is the original line which we removed as part of the fix
6547 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
6548 pEdcaParams->highPerformance;
6549 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6550 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
6551 &pEdcaParams->acbe);
6552 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
6553 &pEdcaParams->acbk);
6554 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
6555 &pEdcaParams->acvi);
6556 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
6557 &pEdcaParams->acvo);
6558 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6559 pWdaParams->pWdaContext = pWDA;
6560 /* Store remove key pointer, as this will be used for response */
6561 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6562 /* store Params pass it to WDI */
6563 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6564 status = WDI_UpdateEDCAParams(wdiEdcaParam,
6565 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6566 if(IS_WDI_STATUS_FAILURE(status))
6567 {
6568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6569 "Failure in Update EDCA Params WDI API, free all the memory " );
6570 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6571 vos_mem_free(pWdaParams);
6572 vos_mem_free(pEdcaParams);
6573 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6574 return CONVERT_WDI2VOS_STATUS(status) ;
6575}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6576/*
6577 * FUNCTION: WDA_AddBAReqCallback
6578 * send ADD BA RSP back to PE
6579 */
6580void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
6581 void* pUserData)
6582{
6583 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6584 tWDA_CbContext *pWDA;
6585 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6587 "<------ %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6588 if (NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6589 {
6590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6591 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6592 VOS_ASSERT(0) ;
6593 return ;
6594 }
6595 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6596 if (NULL == pWDA)
6597 {
6598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6599 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6600 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6601 vos_mem_free(pWdaParams->wdaMsgParam);
6602 vos_mem_free(pWdaParams);
6603
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6604 VOS_ASSERT(0);
6605 return ;
6606 }
6607
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6608 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6609 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6610 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6611 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6612 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6613 return ;
6614}
6615
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6616/*
6617 * FUNCTION: WDA_ProcessAddBAReq
6618 * Request to WDI to Update the ADDBA REQ params.
6619 */
6620VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6621 tANI_U16 baSessionID, tANI_U8 staIdx, tANI_U8 ucWinSize, tAddBAParams *pAddBAReqParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6622{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6623 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6624 WDI_AddBAReqParamsType *wdiAddBAReqParam =
6625 (WDI_AddBAReqParamsType *)vos_mem_malloc(
6626 sizeof(WDI_AddBAReqParamsType)) ;
6627 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6629 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6630 if(NULL == wdiAddBAReqParam)
6631 {
6632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6633 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6634 VOS_ASSERT(0);
6635 return VOS_STATUS_E_NOMEM;
6636 }
6637 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6638 if(NULL == pWdaParams)
6639 {
6640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6641 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6642 VOS_ASSERT(0);
6643 vos_mem_free(wdiAddBAReqParam);
6644 return VOS_STATUS_E_NOMEM;
6645 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6646 do
6647 {
6648 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6649 wdiAddBaInfo->ucSTAIdx = staIdx ;
6650 wdiAddBaInfo->ucBaSessionID = baSessionID ;
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6651 wdiAddBaInfo->ucWinSize = ucWinSize ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6652 } while(0) ;
6653 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6654 pWdaParams->pWdaContext = pWDA;
6655 /* store Params pass it to WDI */
6656 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
6657 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6658 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
6659 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6660
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6661 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6662 {
6663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6664 "Failure in ADD BA REQ Params WDI API, free all the memory" );
6665 status = CONVERT_WDI2VOS_STATUS(wstatus);
6666 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6667 vos_mem_free(pWdaParams);
6668 pAddBAReqParams->status = eSIR_FAILURE;
6669 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6670 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6671 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6672}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6673/*
6674 * FUNCTION: WDA_AddBASessionReqCallback
6675 * send ADD BA SESSION RSP back to PE/(or TL)
6676 */
6677void WDA_AddBASessionReqCallback(
6678 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
6679{
6680 VOS_STATUS status = VOS_STATUS_SUCCESS ;
6681 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6682 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6683 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6685 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6686 if(NULL == pWdaParams)
6687 {
6688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6689 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6690 VOS_ASSERT(0) ;
6691 return ;
6692 }
6693 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6694 if (NULL == pWDA)
6695 {
6696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6697 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6698 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6699 vos_mem_free(pWdaParams->wdaMsgParam);
6700 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6701 VOS_ASSERT(0);
6702 return ;
6703 }
6704
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6705 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6706 if( NULL == pAddBAReqParams )
6707 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6709 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6710 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6711 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6712 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6713 return ;
6714 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6715 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6716 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6717 /*
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]6718 * if BA direction is for recipient, update TL with BA session params and send
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6719 * another request to HAL(/WDI) (ADD_BA_REQ)
6720 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6721 if((VOS_STATUS_SUCCESS ==
6722 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]6723 (eBA_RECIPIENT == pAddBAReqParams->baDirection))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6724 {
6725 /* Update TL with BA info received from HAL/WDI */
6726 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
6727 wdiAddBaSession->usBaSessionID,
6728 wdiAddBaSession->ucSTAIdx,
6729 wdiAddBaSession->ucBaTID,
6730 wdiAddBaSession->ucBaBufferSize,
6731 wdiAddBaSession->ucWinSize,
6732 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6733 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6734 wdiAddBaSession->ucSTAIdx,
6735 wdiAddBaSession->ucWinSize, pAddBAReqParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6736 }
6737 else
6738 {
6739 pAddBAReqParams->status =
6740 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6741
6742 /* Setting Flag to indicate that Set BA is success */
6743 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6744 {
6745 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6746 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6747 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6748 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6749 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6751 /*Reset the WDA state to READY */
6752 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6753 return ;
6754}
6755
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6756/*
6757 * FUNCTION: WDA_ProcessAddBASessionReq
6758 * Request to WDI to Update the ADDBA REQ params.
6759 */
6760VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6761 tAddBAParams *pAddBAReqParams)
6762{
6763 WDI_Status status = WDI_STATUS_SUCCESS ;
6764 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6765 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6766 sizeof(WDI_AddBASessionReqParamsType)) ;
6767 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6768 WLANTL_STAStateType tlSTAState = 0;
6769
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6771 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6772 if(NULL == wdiAddBASessionReqParam)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 VOS_ASSERT(0);
6777 return VOS_STATUS_E_NOMEM;
6778 }
6779 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6780 if(NULL == pWdaParams)
6781 {
6782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6783 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6784 VOS_ASSERT(0);
6785 vos_mem_free(wdiAddBASessionReqParam);
6786 return VOS_STATUS_E_NOMEM;
6787 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6788 /*
6789 * Populate ADD BA parameters and pass these paarmeters to WDI.
6790 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6791 * the state to track if these is BA recipient case or BA initiator
6792 * case.
6793 */
6794 do
6795 {
6796 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6797 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6798 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6799 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6800 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6801 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6802 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6803 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6804 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6805 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6806 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6807 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6808 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]6809
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6810 }while(0) ;
6811 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6812 pWdaParams->pWdaContext = pWDA;
6813 /* Store ADD BA pointer, as this will be used for response */
6814 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6815 /* store Params pass it to WDI */
6816 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6817
6818 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6819 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6820 */
6821 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6822 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6823 {
6824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6825 "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]6826 status = WDI_STATUS_E_NOT_ALLOWED;
6827 pAddBAReqParams->status =
6828 CONVERT_WDI2SIR_STATUS(status) ;
6829 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6830 /*Reset the WDA state to READY */
6831 pWDA->wdaState = WDA_READY_STATE;
6832 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6833 vos_mem_free(pWdaParams);
6834
6835 return CONVERT_WDI2VOS_STATUS(status) ;
6836 }
6837
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6838 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6839 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6840 if(IS_WDI_STATUS_FAILURE(status))
6841 {
6842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6843 "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]6844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6845 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6846 pAddBAReqParams->status =
6847 CONVERT_WDI2SIR_STATUS(status) ;
6848 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6849 /*Reset the WDA state to READY */
6850 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6851 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6852 vos_mem_free(pWdaParams);
6853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6854 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6856/*
6857 * FUNCTION: WDA_DelBANotifyTL
6858 * send DEL BA IND to TL
6859 */
6860void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6861 tDelBAParams *pDelBAReqParams)
6862{
6863 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6864 //tSirMsgQ msg;
6865 vos_msg_t vosMsg;
6866 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6867 if(NULL == pDelBAInd)
6868 {
6869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6870 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6871 VOS_ASSERT(0) ;
6872 return;
6873 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6874 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6875 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6876 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6877 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6878
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6879
6880 vosMsg.type = WDA_DELETEBA_IND;
6881 vosMsg.bodyptr = pDelBAInd;
6882 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6883 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6884 {
6885 vosStatus = VOS_STATUS_E_BADMSG;
6886 }
6887}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6888/*
6889 * FUNCTION: WDA_DelBAReqCallback
6890 * send DEL BA RSP back to PE
6891 */
6892void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6893{
6894 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6895 tWDA_CbContext *pWDA;
6896 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6898 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6899 if(NULL == pWdaParams)
6900 {
6901 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6902 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6903 VOS_ASSERT(0) ;
6904 return ;
6905 }
6906 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6907
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6908 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6909 /* Notify TL about DEL BA in case of recipinet */
6910 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6911 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6912 {
6913 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6915 /*
6916 * No respone required for WDA_DELBA_IND so just free the request
6917 * param here
6918 */
6919 vos_mem_free(pDelBAReqParams);
6920 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6921 vos_mem_free(pWdaParams);
6922 return ;
6923}
6924
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6925/*
6926 * FUNCTION: WDA_ProcessDelBAReq
6927 * Request to WDI to Update the DELBA REQ params.
6928 */
6929VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6930 tDelBAParams *pDelBAReqParams)
6931{
6932 WDI_Status status = WDI_STATUS_SUCCESS ;
6933 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6934 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6935 sizeof(WDI_DelBAReqParamsType)) ;
6936 tWDA_ReqParams *pWdaParams ;
6937 tANI_U16 staIdx = 0;
6938 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6940 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6941 if(NULL == wdiDelBAReqParam)
6942 {
6943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6944 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6945 VOS_ASSERT(0);
6946 return VOS_STATUS_E_NOMEM;
6947 }
6948 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6949 if(NULL == pWdaParams)
6950 {
6951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6952 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6953 VOS_ASSERT(0);
6954 vos_mem_free(wdiDelBAReqParam);
6955 return VOS_STATUS_E_NOMEM;
6956 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6957 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6958 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6959 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6960 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6961 pWdaParams->pWdaContext = pWDA;
6962 /* Store DEL BA pointer, as this will be used for response */
6963 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6964 /* store Params pass it to WDI */
6965 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6966 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6967 * maintained in WDA, so that WDA can retry for another BA session
6968 */
6969 staIdx = pDelBAReqParams->staIdx;
6970 tid = pDelBAReqParams->baTID;
6971 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6972 status = WDI_DelBAReq(wdiDelBAReqParam,
6973 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6974 if(IS_WDI_STATUS_FAILURE(status))
6975 {
6976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6977 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6979 vos_mem_free(pWdaParams->wdaMsgParam);
6980 vos_mem_free(pWdaParams);
6981 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6982 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6983}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6984
6985/*
6986 * FUNCTION: WDA_UpdateChReqCallback
6987 *
6988 */
6989void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6990{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6991 tWDA_ReqParams *pWdaParams;
6992 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6993 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6994 WDI_UpdateChannelReqinfoType *pChanInfoType;
6995 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6996
6997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6998 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6999 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7000 {
7001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7002 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7003 VOS_ASSERT(0);
7004 return;
7005 }
7006
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7007 pWdaParams = (tWDA_ReqParams *)pUserData;
7008 pwdiUpdateChReqParam =
7009 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
7010 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
7011 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
7012 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7013 /*
7014 * currently there is no response message is expected between PE and
7015 * WDA, Failure return from WDI is a ASSERT condition
7016 */
7017 vos_mem_free(pChanInfoType);
7018 vos_mem_free(pChanList);
7019 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7020 vos_mem_free(pWdaParams);
7021
7022 return;
7023}
7024
7025/*
7026 * FUNCTION: WDA_ProcessUpdateChannelList
7027 * Request to WDI to Update the ChannelList params.
7028 */
7029VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
7030 tSirUpdateChanList *pChanList)
7031{
7032 WDI_Status status = WDI_STATUS_SUCCESS;
7033 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
7034 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
7035 WDI_UpdateChannelReqinfoType *pChanInfoType;
7036 tWDA_ReqParams *pWdaParams;
7037 wpt_uint8 i;
7038
7039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7040 "------> %s " ,__func__);
7041 if(NULL == pChanList)
7042 {
7043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7044 "%s: NULL pChanList", __func__);
7045 VOS_ASSERT(0);
7046 return VOS_STATUS_E_INVAL;
7047 }
7048
7049 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
7050 {
Ratheesh S P36dbc932015-08-07 14:28:57 +0530[diff] [blame]7051 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7052 "Update channel list capability Not Supported");
7053 vos_mem_free(pChanList);
7054 return VOS_STATUS_E_INVAL;
7055 }
7056
7057 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
7058 sizeof(WDI_UpdateChReqParamsType));
7059 if(NULL == pwdiUpdateChReqParam)
7060 {
7061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7062 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
7063 __func__);
7064 VOS_ASSERT(0);
7065 vos_mem_free(pChanList);
7066 return VOS_STATUS_E_NOMEM;
7067 }
7068 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
7069 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
7070 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
7071 pChanList->numChan);
7072 if(NULL == pChanInfoType)
7073 {
7074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7075 "%s: VOS MEM Alloc Failure", __func__);
7076 VOS_ASSERT(0);
7077 vos_mem_free(pChanList);
7078 vos_mem_free(pwdiUpdateChReqParam);
7079 return VOS_STATUS_E_NOMEM;
7080 }
7081 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
7082 * pChanList->numChan);
7083 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
7084
7085 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7086 if(NULL == pWdaParams)
7087 {
7088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7089 "%s: VOS MEM Alloc Failure", __func__);
7090 VOS_ASSERT(0);
7091 vos_mem_free(pChanList);
7092 vos_mem_free(pChanInfoType);
7093 vos_mem_free(pwdiUpdateChReqParam);
7094 return VOS_STATUS_E_NOMEM;
7095 }
7096 pwdiUpdateChanReqType->numchan = pChanList->numChan;
7097
7098 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
7099 {
7100 pChanInfoType->mhz =
7101 vos_chan_to_freq(pChanList->chanParam[i].chanId);
7102
7103 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
7104 pChanInfoType->band_center_freq2 = 0;
7105
7106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7107 "chan[%d] = %u", i, pChanInfoType->mhz);
7108 if (pChanList->chanParam[i].dfsSet)
7109 {
7110 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
7111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7112 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
7113 pChanList->chanParam[i].dfsSet);
7114 }
7115
7116 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
7117 {
7118 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
7119 }
7120 else
7121 {
7122 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
7123 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
7124 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
7125 }
7126
7127 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
7128 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
Sachin Ahujacb64fc82015-01-12 17:01:05 +0530[diff] [blame]7129 WDA_SET_CUURENT_REG_DOMAIN(pChanInfoType, pChanList->regId);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7130 pChanInfoType++;
7131 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7132 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
7133 pWdaParams->pWdaContext = pWDA;
7134 pWdaParams->wdaMsgParam = (void *)pChanList;
7135 /* store Params pass it to WDI */
7136 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
7137 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
7138 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
7139 if(IS_WDI_STATUS_FAILURE(status))
7140 {
7141 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7142 "Failure in Update Channel REQ Params WDI API, free all the memory");
7143 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
7144 vos_mem_free(pwdiUpdateChReqParam);
7145 vos_mem_free(pWdaParams->wdaMsgParam);
7146 vos_mem_free(pWdaParams);
7147 }
7148 return CONVERT_WDI2VOS_STATUS(status);
7149}
7150
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7151/*
7152 * FUNCTION: WDA_AddTSReqCallback
7153 * send ADD TS RSP back to PE
7154 */
7155void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
7156{
7157 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7158 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7159 tAddTsParams *pAddTsReqParams;
7160
7161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7162 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7163 if(NULL == pWdaParams)
7164 {
7165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7166 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7167 VOS_ASSERT(0) ;
7168 return ;
7169 }
7170 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7171 if (NULL == pWDA)
7172 {
7173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7174 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]7175 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7176 vos_mem_free(pWdaParams->wdaMsgParam);
7177 vos_mem_free(pWdaParams);
7178
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7179 VOS_ASSERT(0);
7180 return ;
7181 }
7182
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7183 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
7184 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7185 vos_mem_free(pWdaParams);
7186
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7187 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7188 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7189 return ;
7190}
7191
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7192/*
7193 * FUNCTION: WDA_ProcessAddTSReq
7194 * Request to WDI to Update the ADD TS REQ params.
7195 */
7196VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
7197 tAddTsParams *pAddTsReqParams)
7198{
7199 WDI_Status status = WDI_STATUS_SUCCESS ;
7200 WDI_AddTSReqParamsType *wdiAddTSReqParam =
7201 (WDI_AddTSReqParamsType *)vos_mem_malloc(
7202 sizeof(WDI_AddTSReqParamsType)) ;
7203 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7205 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7206 if(NULL == wdiAddTSReqParam)
7207 {
7208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7209 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7210 VOS_ASSERT(0);
7211 return VOS_STATUS_E_NOMEM;
7212 }
7213 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7214 if(NULL == pWdaParams)
7215 {
7216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7217 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7218 VOS_ASSERT(0);
7219 vos_mem_free(wdiAddTSReqParam);
7220 return VOS_STATUS_E_NOMEM;
7221 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7222 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
7223 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7224 //TS IE
7225 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
7226 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
7227 pAddTsReqParams->tspec.length;
7228
7229 //TS IE : TS INFO : TRAFFIC
7230 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
7231 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
7232 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
7233 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
7234 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
7235 pAddTsReqParams->tspec.tsinfo.traffic.psb;
7236 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
7237 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
7238 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
7239 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
7240 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
7241 pAddTsReqParams->tspec.tsinfo.traffic.direction;
7242 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
7243 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
7244 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
7245 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
7246
7247 //TS IE : TS INFO : SCHEDULE
7248 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
7249 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
7250 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
7251 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7252 //TS IE
7253 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
7254 pAddTsReqParams->tspec.nomMsduSz;
7255 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
7256 pAddTsReqParams->tspec.maxMsduSz;
7257 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
7258 pAddTsReqParams->tspec.minSvcInterval;
7259 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
7260 pAddTsReqParams->tspec.maxSvcInterval;
7261 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
7262 pAddTsReqParams->tspec.inactInterval;
7263 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
7264 pAddTsReqParams->tspec.suspendInterval;
7265 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
7266 pAddTsReqParams->tspec.svcStartTime;
7267 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
7268 pAddTsReqParams->tspec.minDataRate;
7269 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
7270 pAddTsReqParams->tspec.meanDataRate;
7271 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
7272 pAddTsReqParams->tspec.peakDataRate;
7273 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
7274 pAddTsReqParams->tspec.maxBurstSz;
7275 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
7276 pAddTsReqParams->tspec.delayBound;
7277 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
7278 pAddTsReqParams->tspec.minPhyRate;
7279 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
7280 pAddTsReqParams->tspec.surplusBw;
7281 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
7282 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7283 /* TODO: tAddTsParams doesn't have the following fields */
7284#if 0
7285 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7286 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
7287 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7288 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7289#endif
7290 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
7291
7292 pWdaParams->pWdaContext = pWDA;
7293 /* Store ADD TS pointer, as this will be used for response */
7294 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7295 /* store Params pass it to WDI */
7296 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7297 status = WDI_AddTSReq(wdiAddTSReqParam,
7298 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7299 if(IS_WDI_STATUS_FAILURE(status))
7300 {
7301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7302 "Failure in ADD TS REQ Params WDI API, free all the memory " );
7303 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7304 vos_mem_free(pWdaParams);
7305 pAddTsReqParams->status = eSIR_FAILURE ;
7306 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
7307 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7308 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7309}
7310
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7311/*
7312 * FUNCTION: WDA_DelTSReqCallback
7313 * send DEL TS RSP back to PE
7314 */
7315void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
7316{
7317 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7319 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7320 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7321 vos_mem_free(pWdaParams->wdaMsgParam) ;
7322 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7323 /*
7324 * No respone required for WDA_DEL_TS_REQ so just free the request
7325 * 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_ProcessDelTSReq
7332 * Request to WDI to Update the DELTS REQ params.
7333 */
7334VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
7335 tDelTsParams *pDelTSReqParams)
7336{
7337 WDI_Status status = WDI_STATUS_SUCCESS ;
7338 WDI_DelTSReqParamsType *wdiDelTSReqParam =
7339 (WDI_DelTSReqParamsType *)vos_mem_malloc(
7340 sizeof(WDI_DelTSReqParamsType)) ;
7341 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7343 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7344 if(NULL == wdiDelTSReqParam)
7345 {
7346 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7347 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7348 VOS_ASSERT(0);
7349 return VOS_STATUS_E_NOMEM;
7350 }
7351 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7352 if(NULL == pWdaParams)
7353 {
7354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7355 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7356 VOS_ASSERT(0);
7357 vos_mem_free(wdiDelTSReqParam);
7358 return VOS_STATUS_E_NOMEM;
7359 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7360 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
7361 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
7362 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
7363 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
7364 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7365 pWdaParams->pWdaContext = pWDA;
7366 /* Store DEL TS pointer, as this will be used for response */
7367 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7368 /* store Params pass it to WDI */
7369 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7370 status = WDI_DelTSReq(wdiDelTSReqParam,
7371 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7372 if(IS_WDI_STATUS_FAILURE(status))
7373 {
7374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7375 "Failure in DEL TS REQ Params WDI API, free all the memory " );
7376 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7377 vos_mem_free(pWdaParams->wdaMsgParam);
7378 vos_mem_free(pWdaParams);
7379 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7380 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7381}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7382/*
7383 * FUNCTION: WDA_UpdateBeaconParamsCallback
7384 * Free the memory. No need to send any response to PE in this case
7385 */
7386void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
7387{
7388 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7390 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7391 if(NULL == pWdaParams)
7392 {
7393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7394 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7395 VOS_ASSERT(0) ;
7396 return ;
7397 }
7398 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7399 vos_mem_free(pWdaParams->wdaMsgParam) ;
7400 vos_mem_free(pWdaParams);
7401 /*
7402 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
7403 * param here
7404 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7405 return ;
7406}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7407/*
7408 * FUNCTION: WDA_ProcessUpdateBeaconParams
7409 * Request to WDI to send the beacon parameters to HAL to update the Hardware
7410 */
7411VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
7412 tUpdateBeaconParams *pUpdateBeaconParams)
7413{
7414 WDI_Status status = WDI_STATUS_SUCCESS ;
7415 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
7416 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
7417 sizeof(WDI_UpdateBeaconParamsType)) ;
7418 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7420 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7421 if(NULL == wdiUpdateBeaconParams)
7422 {
7423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7424 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7425 VOS_ASSERT(0);
7426 return VOS_STATUS_E_NOMEM;
7427 }
7428 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7429 if(NULL == pWdaParams)
7430 {
7431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7432 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7433 VOS_ASSERT(0);
7434 vos_mem_free(wdiUpdateBeaconParams);
7435 return VOS_STATUS_E_NOMEM;
7436 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7437 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
7438 pUpdateBeaconParams->bssIdx;
7439 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
7440 pUpdateBeaconParams->fShortPreamble;
7441 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
7442 pUpdateBeaconParams->fShortSlotTime;
7443 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
7444 pUpdateBeaconParams->beaconInterval;
7445 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
7446 pUpdateBeaconParams->llaCoexist;
7447 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
7448 pUpdateBeaconParams->llbCoexist;
7449 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
7450 pUpdateBeaconParams->llgCoexist;
7451 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
7452 pUpdateBeaconParams->ht20MhzCoexist;
7453 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
7454 pUpdateBeaconParams->llnNonGFCoexist;
7455 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
7456 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
7457 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
7458 pUpdateBeaconParams->fRIFSMode;
7459 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
7460 pUpdateBeaconParams->paramChangeBitmap;
7461 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
7462
7463 pWdaParams->pWdaContext = pWDA;
7464 /* Store UpdateBeacon Req pointer, as this will be used for response */
7465 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7466 /* store Params pass it to WDI */
7467 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7468 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
7469 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
7470 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7471 if(IS_WDI_STATUS_FAILURE(status))
7472 {
7473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7474 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
7475 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7476 vos_mem_free(pWdaParams->wdaMsgParam);
7477 vos_mem_free(pWdaParams);
7478 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7479 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7480}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7481#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7482/*
7483 * FUNCTION: WDA_TSMStatsReqCallback
7484 * send TSM Stats RSP back to PE
7485 */
7486void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
7487{
7488 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7489 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7490 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
7491 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7492
7493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7494 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7495 if(NULL == pWdaParams)
7496 {
7497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7498 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7499 VOS_ASSERT(0) ;
7500 return ;
7501 }
7502 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7503 if (NULL == pWDA)
7504 {
7505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7506 "%s:pWDA is NULL", __func__);
7507 VOS_ASSERT(0);
7508 return ;
7509 }
7510
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7511 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
7512
7513 if(NULL == pGetTsmStatsReqParams)
7514 {
7515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7516 "%s: pGetTsmStatsReqParams received NULL", __func__);
7517 VOS_ASSERT(0);
7518 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7519 vos_mem_free(pWdaParams);
7520 return;
7521 }
7522
7523 pTsmRspParams =
7524 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7525 if( NULL == pTsmRspParams )
7526 {
7527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7528 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7529 VOS_ASSERT( 0 );
7530 return ;
7531 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7532 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
7533 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
7534 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
7535
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7536 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
7537 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
7538 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
7539 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
7540 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
7541 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
7542 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
7543 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
7544 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
7545 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7546
7547 /* Assign get tsm stats req req (backup) in to the response */
7548 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
7549
7550 /* free WDI command buffer */
7551 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7552 vos_mem_free(pWdaParams);
7553
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7554 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7555 return ;
7556}
7557
7558
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7559/*
7560 * FUNCTION: WDA_ProcessTsmStatsReq
7561 * Request to WDI to get the TSM Stats params.
7562 */
7563VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7564 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7565{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7566 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7567 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7568 tWDA_ReqParams *pWdaParams = NULL;
7569 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
7570
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7572 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7573 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
7574 sizeof(WDI_TSMStatsReqParamsType));
7575 if(NULL == wdiTSMReqParam)
7576 {
7577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7578 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7579 VOS_ASSERT(0);
7580 return VOS_STATUS_E_NOMEM;
7581 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7582 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7583 if(NULL == pWdaParams)
7584 {
7585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7586 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7587 VOS_ASSERT(0);
7588 vos_mem_free(wdiTSMReqParam);
7589 return VOS_STATUS_E_NOMEM;
7590 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7591 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
7592 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
7593 pTsmStats->bssId,
7594 sizeof(wpt_macAddr));
7595 wdiTSMReqParam->wdiReqStatusCB = NULL ;
7596
7597 pWdaParams->pWdaContext = pWDA;
7598 /* Store TSM Stats pointer, as this will be used for response */
7599 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7600 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7601 status = WDI_TSMStatsReq(wdiTSMReqParam,
7602 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7603 if(IS_WDI_STATUS_FAILURE(status))
7604 {
7605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7606 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7607 vos_mem_free(pWdaParams);
7608
7609 pGetTsmStatsRspParams =
7610 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
7611 if(NULL == pGetTsmStatsRspParams)
7612 {
7613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7614 "%s: VOS MEM Alloc Failure", __func__);
7615 VOS_ASSERT(0);
7616 vos_mem_free(pTsmStats);
7617 return VOS_STATUS_E_NOMEM;
7618 }
7619 pGetTsmStatsRspParams->staId = pTsmStats->staId;
7620 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
7621 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
7622
7623 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7624 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7625 return CONVERT_WDI2VOS_STATUS(status) ;
7626}
7627#endif
7628/*
7629 * FUNCTION: WDA_SendBeaconParamsCallback
7630 * No need to send any response to PE in this case
7631 */
7632void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
7633{
7634
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7636 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7637 return ;
7638}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7639/*
7640 * FUNCTION: WDA_ProcessSendBeacon
7641 * Request to WDI to send the beacon template to HAL to update the TPE memory and
7642 * start beacon trasmission
7643 */
7644VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
7645 tSendbeaconParams *pSendbeaconParams)
7646{
7647 WDI_Status status = WDI_STATUS_SUCCESS ;
7648 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7650 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7651 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
7652 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
7653 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
7654 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7655 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
7656 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]7657 /* p2pIeOffset should be atleast greater than timIeOffset */
7658 if ((pSendbeaconParams->p2pIeOffset != 0) &&
7659 (pSendbeaconParams->p2pIeOffset <
7660 pSendbeaconParams->timIeOffset))
7661 {
7662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7663 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7664 vos_mem_free(pSendbeaconParams);
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]7665 VOS_ASSERT( 0 );
7666 return WDI_STATUS_E_FAILURE;
7667 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7668 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
7669 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7670 /* Copy the beacon template to local buffer */
7671 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
7672 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
7673 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
7674
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7675 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
7676 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7677 if(IS_WDI_STATUS_FAILURE(status))
7678 {
7679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7680 "Failure in SEND BEACON REQ Params WDI API" );
7681 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7682 vos_mem_free(pSendbeaconParams);
7683 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7684}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7685/*
7686 * FUNCTION: WDA_UpdateProbeRspParamsCallback
7687 * No need to send any response to PE in this case
7688 */
7689void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
7690{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7692 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7693 return ;
7694}
7695
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7696/*
7697 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
7698 * Request to WDI to send the probe response template to HAL to update the TPE memory and
7699 * send probe response
7700 */
7701VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
7702 tSendProbeRespParams *pSendProbeRspParams)
7703{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7704 WDI_Status status = WDI_STATUS_SUCCESS;
7705 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
7706 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7708 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7709
7710 if (!wdiSendProbeRspParam)
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7711 {
7712 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7713 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7714 }
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7715
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7716 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7717 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7718 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7719 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7720 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7721 /* Copy the Probe Response template to local buffer */
7722 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7723 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7724 pSendProbeRspParams->pProbeRespTemplate,
7725 pSendProbeRspParams->probeRespTemplateLen);
7726 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7727 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7728 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
7729 WDI_PROBE_REQ_BITMAP_IE_LEN);
7730
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7731 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7732
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7733 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7734 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7735 if(IS_WDI_STATUS_FAILURE(status))
7736 {
7737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7738 "Failure in SEND Probe RSP Params WDI API" );
7739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7740 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7741 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7742 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7743}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7744#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7745/*
7746 * FUNCTION: WDA_SetMaxTxPowerCallBack
7747 * send the response to PE with power value received from WDI
7748 */
7749void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7750 void* pUserData)
7751{
7752 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7753 tWDA_CbContext *pWDA = NULL;
7754 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
7755
7756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7757 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7758 if(NULL == pWdaParams)
7759 {
7760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7761 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7762 VOS_ASSERT(0) ;
7763 return ;
7764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7765 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7766 if (NULL == pWDA)
7767 {
7768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7769 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]7770 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7771 vos_mem_free(pWdaParams->wdaMsgParam);
7772 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7773 VOS_ASSERT(0);
7774 return ;
7775 }
7776
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7777 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7778 if( NULL == pMaxTxPowerParams )
7779 {
7780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7781 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7782 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7783 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7784 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7785 return ;
7786 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7787
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7788
7789 /*need to free memory for the pointers used in the
7790 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7791 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7792 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7793 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7795
7796 /* send response to UMAC*/
7797 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7798
7799 return;
7800}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7801/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7802 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7803 * Request to WDI to send set Max Tx Power Request
7804 */
7805 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7806 tMaxTxPowerParams *MaxTxPowerParams)
7807{
7808 WDI_Status status = WDI_STATUS_SUCCESS;
7809 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7810 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7811
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7813 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7814
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7815 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7816 sizeof(WDI_SetMaxTxPowerParamsType));
7817 if(NULL == wdiSetMaxTxPowerParams)
7818 {
7819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7820 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7821 VOS_ASSERT(0);
7822 return VOS_STATUS_E_NOMEM;
7823 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7824 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7825 if(NULL == pWdaParams)
7826 {
7827 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7828 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7829 vos_mem_free(wdiSetMaxTxPowerParams);
7830 VOS_ASSERT(0);
7831 return VOS_STATUS_E_NOMEM;
7832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7833 /* Copy.Max.Tx.Power Params to WDI structure */
7834 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7835 MaxTxPowerParams->bssId,
7836 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7837 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7838 MaxTxPowerParams->selfStaMacAddr,
7839 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7840 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7841 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7842 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7843 pWdaParams->pWdaContext = pWDA;
7844 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7845 /* store Params pass it to WDI */
7846 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7847 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7848 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7849 if(IS_WDI_STATUS_FAILURE(status))
7850 {
7851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7852 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7853 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7854 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7855 /* send response to UMAC*/
7856 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7857 }
7858 return CONVERT_WDI2VOS_STATUS(status);
7859
7860}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7861#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7862
7863/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7864 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7865 * send the response to PE with power value received from WDI
7866 */
7867void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7868 *pwdiSetMaxTxPowerPerBandRsp,
7869 void* pUserData)
7870{
7871 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7872 tWDA_CbContext *pWDA = NULL;
7873 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7874
7875 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7876 "<------ %s ", __func__);
7877 if (NULL == pWdaParams)
7878 {
7879 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7880 "%s: pWdaParams received NULL", __func__);
7881 VOS_ASSERT(0);
7882 return ;
7883 }
7884 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7885 if (NULL == pWDA)
7886 {
7887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7888 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]7889 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7890 vos_mem_free(pWdaParams->wdaMsgParam);
7891 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7892 VOS_ASSERT(0);
7893 return ;
7894 }
7895
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7896 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7897 if ( NULL == pMxTxPwrPerBandParams )
7898 {
7899 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7900 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7901 VOS_ASSERT(0);
7902 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7903 vos_mem_free(pWdaParams);
7904 return;
7905 }
7906
7907 /*need to free memory for the pointers used in the
7908 WDA Process.Set Max Tx Power Req function*/
7909 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7910 vos_mem_free(pWdaParams);
7911 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7912
7913 /* send response to UMAC*/
7914 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7915 pMxTxPwrPerBandParams, 0);
7916
7917 return;
7918}
7919
7920/*
7921 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7922 * Request to WDI to send set Max Tx Power Per band Request
7923 */
7924 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7925 tMaxTxPowerPerBandParams
7926 *MaxTxPowerPerBandParams)
7927{
7928 WDI_Status status = WDI_STATUS_SUCCESS;
7929 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7930 tWDA_ReqParams *pWdaParams = NULL;
7931
7932 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7933 "------> %s ", __func__);
7934
7935 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7936 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7937
7938 if (NULL == wdiSetMxTxPwrPerBandParams)
7939 {
7940 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7941 "%s: VOS MEM Alloc Failure", __func__);
7942 VOS_ASSERT(0);
7943 return VOS_STATUS_E_NOMEM;
7944 }
7945 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7946 if (NULL == pWdaParams)
7947 {
7948 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7949 "%s: VOS MEM Alloc Failure", __func__);
7950 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7951 VOS_ASSERT(0);
7952 return VOS_STATUS_E_NOMEM;
7953 }
7954 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7955 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7956 MaxTxPowerPerBandParams->bandInfo;
7957 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7958 MaxTxPowerPerBandParams->power;
7959 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7960 pWdaParams->pWdaContext = pWDA;
7961 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7962 /* store Params pass it to WDI */
7963 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7964 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7965 WDA_SetMaxTxPowerPerBandCallBack,
7966 pWdaParams);
7967 if (IS_WDI_STATUS_FAILURE(status))
7968 {
7969 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7970 "Failure in SET MAX TX Power REQ Params WDI API,"
7971 " free all the memory");
7972 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7973 vos_mem_free(pWdaParams);
7974 /* send response to UMAC*/
7975 WDA_SendMsg(pWDA,
7976 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7977 MaxTxPowerPerBandParams, 0);
7978 }
7979 return CONVERT_WDI2VOS_STATUS(status);
7980}
7981
7982/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7983 * FUNCTION: WDA_SetTxPowerCallBack
7984 * send the response to PE with power value received from WDI
7985 */
7986void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7987 void* pUserData)
7988{
7989 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7990 tWDA_CbContext *pWDA = NULL;
7991 tSirSetTxPowerReq *pTxPowerParams = NULL;
7992
7993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7994 "<------ %s ", __func__);
7995 if(NULL == pWdaParams)
7996 {
7997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7998 "%s: pWdaParams received NULL", __func__);
7999 VOS_ASSERT(0) ;
8000 return ;
8001 }
8002 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8003 if (NULL == pWDA)
8004 {
8005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8006 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8007 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8008 vos_mem_free(pWdaParams->wdaMsgParam);
8009 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8010 VOS_ASSERT(0);
8011 return ;
8012 }
8013
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]8014 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
8015 if(NULL == pTxPowerParams)
8016 {
8017 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8018 "%s: pTxPowerParams received NULL " ,__func__);
8019 VOS_ASSERT(0);
8020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8021 vos_mem_free(pWdaParams);
8022 return ;
8023 }
8024
8025 /*need to free memory for the pointers used in the
8026 WDA Process.Set Max Tx Power Req function*/
8027 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8028 vos_mem_free(pWdaParams);
8029
8030 /* send response to UMAC*/
8031 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
8032 return;
8033}
8034
8035/*
8036 * FUNCTION: WDA_ProcessSetTxPowerReq
8037 * Request to WDI to send set Tx Power Request
8038 */
8039 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
8040 tSirSetTxPowerReq *txPowerParams)
8041{
8042 WDI_Status status = WDI_STATUS_SUCCESS;
8043 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
8044 tWDA_ReqParams *pWdaParams = NULL;
8045
8046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8047 "------> %s ", __func__);
8048
8049 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
8050 sizeof(WDI_SetTxPowerParamsType));
8051 if(NULL == wdiSetTxPowerParams)
8052 {
8053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8054 "%s: VOS MEM Alloc Failure", __func__);
8055 VOS_ASSERT(0);
8056 return VOS_STATUS_E_NOMEM;
8057 }
8058 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8059 if(NULL == pWdaParams)
8060 {
8061 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8062 "%s: VOS MEM Alloc Failure", __func__);
8063 vos_mem_free(wdiSetTxPowerParams);
8064 VOS_ASSERT(0);
8065 return VOS_STATUS_E_NOMEM;
8066 }
8067 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
8068 txPowerParams->bssIdx;
8069 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
8070 txPowerParams->mwPower;
8071 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
8072 pWdaParams->pWdaContext = pWDA;
8073 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
8074 /* store Params pass it to WDI */
8075 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
8076 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
8077 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
8078 if(IS_WDI_STATUS_FAILURE(status))
8079 {
8080 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8081 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
8082 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8083 vos_mem_free(pWdaParams);
8084 /* send response to UMAC*/
8085 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
8086 }
8087 return CONVERT_WDI2VOS_STATUS(status);
8088}
8089
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8090/*
8091 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
8092 * Free the memory. No need to send any response to PE in this case
8093 */
8094void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
8095{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8096 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8097
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8099 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8100
8101 if(NULL == pWdaParams)
8102 {
8103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8104 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8105 VOS_ASSERT(0) ;
8106 return ;
8107 }
8108
8109 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8110 vos_mem_free(pWdaParams->wdaMsgParam) ;
8111 vos_mem_free(pWdaParams);
8112
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8113 /*
8114 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
8115 * so just free the request param here
8116 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8117 return ;
8118}
8119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8120/*
8121 * FUNCTION: WDA_ProcessSetP2PGONOAReq
8122 * Request to WDI to set the P2P Group Owner Notice of Absence Req
8123 */
8124VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
8125 tP2pPsParams *pP2pPsConfigParams)
8126{
8127 WDI_Status status = WDI_STATUS_SUCCESS ;
8128 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
8129 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
8130 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8131 tWDA_ReqParams *pWdaParams = NULL;
8132
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8134 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8135 if(NULL == wdiSetP2PGONOAReqParam)
8136 {
8137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8138 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8139 vos_mem_free(pP2pPsConfigParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8140 VOS_ASSERT(0);
8141 return VOS_STATUS_E_NOMEM;
8142 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8143
8144 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8145 if(NULL == pWdaParams)
8146 {
8147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8148 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8149 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8150 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8151 VOS_ASSERT(0);
8152 return VOS_STATUS_E_NOMEM;
8153 }
8154
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8155 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
8156 pP2pPsConfigParams->opp_ps;
8157 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
8158 pP2pPsConfigParams->ctWindow;
8159 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
8160 pP2pPsConfigParams->count;
8161 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
8162 pP2pPsConfigParams->duration;
8163 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
8164 pP2pPsConfigParams->interval;
8165 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
8166 pP2pPsConfigParams->single_noa_duration;
8167 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
8168 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8169
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8170 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
8171 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8172 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
8173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8174 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8175 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
8176 pWdaParams->pWdaContext = pWDA;
8177
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8178 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8179 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
8180
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8181 if(IS_WDI_STATUS_FAILURE(status))
8182 {
8183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8184 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8185 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8186 vos_mem_free(pWdaParams->wdaMsgParam);
8187 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8188 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8189 return CONVERT_WDI2VOS_STATUS(status);
8190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8191}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8192
8193#ifdef FEATURE_WLAN_TDLS
8194/*
8195 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
8196 * Free the memory. No need to send any response to PE in this case
8197 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8198void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
8199 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8200{
8201 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8202 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8203 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8204
8205
8206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8207 "<------ %s " ,__func__);
8208 if(NULL == pWdaParams)
8209 {
8210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8211 "%s: pWdaParams received NULL", __func__);
8212 VOS_ASSERT(0) ;
8213 return ;
8214 }
8215 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
8216
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8217 if (NULL == pWDA)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8218 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8220 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8221 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8222 vos_mem_free(pWdaParams->wdaMsgParam);
8223 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8224 VOS_ASSERT(0);
8225 return ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8226 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8227
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8228 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
8229 if( NULL == pTdlsLinkEstablishParams )
8230 {
8231 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8232 "%s: pTdlsLinkEstablishParams "
8233 "received NULL " ,__func__);
8234 VOS_ASSERT(0);
8235 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8236 vos_mem_free(pWdaParams);
8237 return ;
8238 }
8239 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
8240 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8242 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8243 /* send response to UMAC*/
8244 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
8245
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8246 return ;
8247}
8248
8249VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
8250 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
8251{
8252 WDI_Status status = WDI_STATUS_SUCCESS ;
8253 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
8254 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
8255 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
8256 tWDA_ReqParams *pWdaParams = NULL;
8257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8258 "------> %s " ,__func__);
8259 if(NULL == wdiSetTDLSLinkEstablishReqParam)
8260 {
8261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8262 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8263 vos_mem_free(pTdlsLinkEstablishParams);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8264 VOS_ASSERT(0);
8265 return VOS_STATUS_E_NOMEM;
8266 }
8267 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8268 if(NULL == pWdaParams)
8269 {
8270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8271 "%s: VOS MEM Alloc Failure", __func__);
8272 vos_mem_free(pTdlsLinkEstablishParams);
8273 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
8274 VOS_ASSERT(0);
8275 return VOS_STATUS_E_NOMEM;
8276 }
8277 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8278 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8279 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8280 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8281 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8282 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8283 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8284 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8285 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8286 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]8287 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
8288 pTdlsLinkEstablishParams->isOffChannelSupported;
8289
8290 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
8291 pTdlsLinkEstablishParams->validChannels,
8292 pTdlsLinkEstablishParams->validChannelsLen);
8293
8294 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
8295 pTdlsLinkEstablishParams->validChannelsLen;
8296
8297 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
8298 pTdlsLinkEstablishParams->validOperClasses,
8299 pTdlsLinkEstablishParams->validOperClassesLen);
8300 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
8301 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8302
8303 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
8304 /* Store msg pointer from PE, as this will be used for response */
8305 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
8306 /* store Params pass it to WDI */
8307 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
8308 pWdaParams->pWdaContext = pWDA;
8309
8310 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
8311 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
8312 WDA_SetTDLSLinkEstablishReqParamsCallback,
8313 pWdaParams);
8314 if(IS_WDI_STATUS_FAILURE(status))
8315 {
8316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8317 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
8318 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8319 vos_mem_free(pWdaParams->wdaMsgParam);
8320 vos_mem_free(pWdaParams);
8321 }
8322 return CONVERT_WDI2VOS_STATUS(status);
8323}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8324
8325// tdlsoffchan
8326void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
8327 void* pUserData)
8328{
8329 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8330 tWDA_CbContext *pWDA = NULL;
8331 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
8332
8333
8334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8335 "<------ %s " ,__func__);
8336 if(NULL == pWdaParams)
8337 {
8338 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8339 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8340 VOS_ASSERT(0) ;
8341 return ;
8342 }
8343 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
8344
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8345 if (NULL == pWDA)
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8346 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8348 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8349 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8350 vos_mem_free(pWdaParams->wdaMsgParam);
8351 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8352 VOS_ASSERT(0);
8353 return ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8354 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8355
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8356 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8357 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8358 {
8359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8360 "%s: pTdlsChanSwitchParams "
8361 "received NULL " ,__func__);
8362 VOS_ASSERT(0);
8363 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8364 vos_mem_free(pWdaParams);
8365 return ;
8366 }
8367 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
8368 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8370 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8371 /* send response to UMAC*/
8372 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8373
8374 return ;
8375}
8376VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
8377 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
8378{
8379 WDI_Status status = WDI_STATUS_SUCCESS ;
8380 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
8381 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
8382 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
8383 tWDA_ReqParams *pWdaParams = NULL;
8384
8385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8386 "Enter: %s ",__func__);
8387 if(NULL == wdiSetTDLSChanSwitchReqParam)
8388 {
8389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8390 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8391 vos_mem_free(pTdlsChanSwitchParams);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8392 VOS_ASSERT(0);
8393 return VOS_STATUS_E_NOMEM;
8394 }
8395
8396 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8397 if(NULL == pWdaParams)
8398 {
8399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8400 "%s: VOS MEM Alloc Failure", __func__);
8401 vos_mem_free(pTdlsChanSwitchParams);
8402 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
8403 VOS_ASSERT(0);
8404 return VOS_STATUS_E_NOMEM;
8405 }
8406 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
8407 pTdlsChanSwitchParams->staIdx;
8408 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
8409 pTdlsChanSwitchParams->tdlsSwMode;
8410 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
8411 pTdlsChanSwitchParams->operClass;
8412 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
8413 pTdlsChanSwitchParams->tdlsOffCh;
8414 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
8415 pTdlsChanSwitchParams->tdlsOffChBwOffset;
8416
8417
8418 /* Store msg pointer from PE, as this will be used for response */
8419 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
8420 /* store Params pass it to WDI */
8421 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
8422 pWdaParams->pWdaContext = pWDA;
8423 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
8424 (WDI_SetTDLSChanSwitchReqParamsRspCb)
8425 WDA_SetTDLSChanSwitchReqParamsCallback,
8426 pWdaParams);
8427 if(IS_WDI_STATUS_FAILURE(status))
8428 {
8429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8430 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
8431 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8432 vos_mem_free(pWdaParams->wdaMsgParam);
8433 vos_mem_free(pWdaParams);
8434 }
8435 return CONVERT_WDI2VOS_STATUS(status);
8436}
8437#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8438
8439
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8440#ifdef WLAN_FEATURE_VOWIFI_11R
8441/*
8442 * FUNCTION: WDA_AggrAddTSReqCallback
8443 * send ADD AGGREGATED TS RSP back to PE
8444 */
8445void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
8446{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8447 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8448 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8449 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8450 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8452 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8453 if(NULL == pWdaParams)
8454 {
8455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8456 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8457 VOS_ASSERT(0) ;
8458 return ;
8459 }
8460
8461 pWDA = pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8462 if (NULL == pWDA)
8463 {
8464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8465 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8466 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8467 vos_mem_free(pWdaParams->wdaMsgParam);
8468 vos_mem_free(pWdaParams);
8469
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8470 VOS_ASSERT(0);
8471 return ;
8472 }
8473
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8474 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8475
8476 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
8477 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8478 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8479 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8480 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8481
8482 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8483 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8484 return ;
8485}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8486/*
8487 * FUNCTION: WDA_ProcessAddTSReq
8488 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
8489 */
8490VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
8491 tAggrAddTsParams *pAggrAddTsReqParams)
8492{
8493 WDI_Status status = WDI_STATUS_SUCCESS ;
8494 int i;
8495 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8496 tWDA_ReqParams *pWdaParams = NULL;
8497
8498
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8500 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8501 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
8502 sizeof(WDI_AggrAddTSReqParamsType)) ;
8503 if(NULL == wdiAggrAddTSReqParam)
8504 {
8505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8506 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8507 vos_mem_free(pAggrAddTsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8508 VOS_ASSERT(0);
8509 return VOS_STATUS_E_NOMEM;
8510 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8511
8512
8513 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8514 if(NULL == pWdaParams)
8515 {
8516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8517 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8518 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8519 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8520 VOS_ASSERT(0);
8521 return VOS_STATUS_E_NOMEM;
8522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8523 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
8524 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
8525 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8526 for( i = 0; i < WDI_MAX_NO_AC; i++ )
8527 {
8528 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
8529 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
8530 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8531 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
8532 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
8533 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
8534 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
8535 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
8536 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
8537 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
8538 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
8539 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
8540 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
8541 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
8542 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
8543 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
8544 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
8545 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
8546 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8547 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
8548 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8549 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
8550 pAggrAddTsReqParams->tspec[i].nomMsduSz;
8551 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
8552 pAggrAddTsReqParams->tspec[i].maxMsduSz;
8553 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
8554 pAggrAddTsReqParams->tspec[i].minSvcInterval;
8555 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
8556 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
8557 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
8558 pAggrAddTsReqParams->tspec[i].inactInterval;
8559 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
8560 pAggrAddTsReqParams->tspec[i].suspendInterval;
8561 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
8562 pAggrAddTsReqParams->tspec[i].svcStartTime;
8563 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
8564 pAggrAddTsReqParams->tspec[i].minDataRate;
8565 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
8566 pAggrAddTsReqParams->tspec[i].meanDataRate;
8567 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
8568 pAggrAddTsReqParams->tspec[i].peakDataRate;
8569 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
8570 pAggrAddTsReqParams->tspec[i].maxBurstSz;
8571 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
8572 pAggrAddTsReqParams->tspec[i].delayBound;
8573 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
8574 pAggrAddTsReqParams->tspec[i].minPhyRate;
8575 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
8576 pAggrAddTsReqParams->tspec[i].surplusBw;
8577 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
8578 pAggrAddTsReqParams->tspec[i].mediumTime;
8579 }
8580
8581 /* TODO: tAggrAddTsParams doesn't have the following fields */
8582#if 0
8583 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
8584 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
8585 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
8586 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
8587#endif
8588 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
8589
8590 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8591 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8592 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8593 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
8594
8595 pWdaParams->pWdaContext = pWDA;
8596
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8597 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8598 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
8599
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8600 if(IS_WDI_STATUS_FAILURE(status))
8601 {
8602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8603 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8604 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8605 vos_mem_free(pWdaParams);
8606
8607 /* send the failure response back to PE*/
8608 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
8609 {
8610 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
8611 }
8612
8613 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
8614 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8615 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8616 return CONVERT_WDI2VOS_STATUS(status) ;
8617}
8618#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8619/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8620 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8621 * send Enter IMPS RSP back to PE
8622 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8623void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8624{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8625 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8626 tWDA_CbContext *pWDA = NULL;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8627
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8629 "<------ %s status=%d" ,__func__,status);
8630 if(NULL == pWdaParams)
8631 {
8632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8633 "%s: pWdaParams received NULL", __func__);
8634 VOS_ASSERT(0);
8635 return;
8636 }
8637
8638 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8639 if (NULL == pWDA)
8640 {
8641 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8642 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8643 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8644 vos_mem_free(pWdaParams->wdaMsgParam);
8645 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8646 VOS_ASSERT(0);
8647 return ;
8648 }
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8649
8650 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8651 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8652 if (WDI_STATUS_SUCCESS != status)
8653 {
8654 pWDA->failureCounts.enterImpsFailureCount++;
8655 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8656 pWDA->failureCounts.enterImpsFailureCount)
8657 {
8658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8659 "%s: Status %d fail count %d", __func__, status,
8660 pWDA->failureCounts.enterImpsFailureCount);
8661 pWDA->failureCounts.enterImpsFailureCount = 0;
8662 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8663 WLAN_LOG_INDICATOR_HOST_DRIVER,
8664 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
8665 FALSE, TRUE);
8666 }
8667 }
8668 else
8669 {
8670 pWDA->failureCounts.enterImpsFailureCount = 0;
8671 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8672 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8673 return ;
8674}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8675
8676
8677/*
8678 * FUNCTION: WDA_EnterImpsReqCallback
8679 * Free memory and send Enter IMPS RSP back to PE.
8680 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
8681 */
8682void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8683{
8684 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8685 tWDA_CbContext *pWDA = NULL;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8686
8687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8688 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8689
8690 if(NULL == pWdaParams)
8691 {
8692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8693 "%s: pWdaParams received NULL", __func__);
8694 VOS_ASSERT(0);
8695 return;
8696 }
8697
8698 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8699 if (NULL == pWDA)
8700 {
8701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8702 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8703 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8704 vos_mem_free(pWdaParams->wdaMsgParam);
8705 vos_mem_free(pWdaParams);
8706
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8707 VOS_ASSERT(0);
8708 return ;
8709 }
8710
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8711
8712 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8713 {
8714 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8715 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8716 pWDA->failureCounts.enterImpsFailureCount++;
8717 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8718 pWDA->failureCounts.enterImpsFailureCount)
8719 {
8720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8721 "%s: wdiStatus %d fail count %d", __func__, wdiStatus,
8722 pWDA->failureCounts.enterImpsFailureCount);
8723 pWDA->failureCounts.enterImpsFailureCount = 0;
8724 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8725 WLAN_LOG_INDICATOR_HOST_DRIVER,
8726 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
8727 FALSE, TRUE);
8728 }
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8729 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
8730 CONVERT_WDI2SIR_STATUS(wdiStatus));
8731 }
8732
8733 return;
8734}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8735/*
8736 * FUNCTION: WDA_ProcessEnterImpsReq
8737 * Request to WDI to Enter IMPS power state.
8738 */
8739VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
8740{
8741 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8742 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
8743 tWDA_ReqParams *pWdaParams;
Sushant Kaushik7438e252015-05-01 14:55:09 +0530[diff] [blame]8744 static int failcnt = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8746 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8747
8748
8749 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
8750 if (NULL == wdiEnterImpsReqParams)
8751 {
8752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8753 "%s: VOS MEM Alloc Failure", __func__);
8754 VOS_ASSERT(0);
8755 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
8756 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
8757 return VOS_STATUS_E_NOMEM;
8758 }
8759
8760 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8761 if (NULL == pWdaParams)
8762 {
8763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8764 "%s: VOS MEM Alloc Failure", __func__);
8765 VOS_ASSERT(0);
8766 vos_mem_free(wdiEnterImpsReqParams);
8767 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
8768 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
8769 return VOS_STATUS_E_NOMEM;
8770 }
8771
8772 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
8773 wdiEnterImpsReqParams->pUserData = pWdaParams;
8774
8775 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
8776 pWdaParams->wdaMsgParam = NULL;
8777 pWdaParams->pWdaContext = pWDA;
8778
8779 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
8780 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
8781 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8782 if(IS_WDI_STATUS_FAILURE(status))
8783 {
Sushant Kaushik7438e252015-05-01 14:55:09 +0530[diff] [blame]8784 if (! (failcnt & 0xF))
8785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8786 "Failure in Enter IMPS REQ WDI API, free all the memory " );
8787 failcnt++;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8788 vos_mem_free(wdiEnterImpsReqParams);
8789 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8790 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8792 return CONVERT_WDI2VOS_STATUS(status) ;
8793}
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8794
8795/*
8796 * FUNCTION: WDA_ExitImpsRespCallback
8797 * send Exit IMPS RSP back to PE
8798 */
8799void WDA_ExitImpsRespCallback(WDI_Status status, void* pUserData)
8800{
8801 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8802 tWDA_CbContext *pWDA;
8803
8804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8805 "<------ %s " ,__func__);
8806
8807 if (NULL == pWdaParams)
8808 {
8809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8810 "%s: pWdaParams received NULL", __func__);
8811 VOS_ASSERT(0);
8812 return;
8813 }
8814 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8815
8816 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8817 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8818 if (WDI_STATUS_SUCCESS != status)
8819 {
8820 pWDA->failureCounts.exitImpsFailureCount++;
8821 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8822 pWDA->failureCounts.exitImpsFailureCount)
8823 {
8824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8825 "%s: Status %d fail count %d", __func__,
8826 status,
8827 pWDA->failureCounts.exitImpsFailureCount);
8828 pWDA->failureCounts.exitImpsFailureCount = 0;
8829 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8830 WLAN_LOG_INDICATOR_HOST_DRIVER,
8831 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
8832 FALSE, TRUE);
8833 }
8834 }
8835 else
8836 {
8837 pWDA->failureCounts.exitImpsFailureCount = 0;
8838 }
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8839
8840 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status));
8841 return;
8842}
8843
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8844/*
8845 * FUNCTION: WDA_ExitImpsReqCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8846 */
8847void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
8848{
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8849 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8850 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8852 "<------ %s " ,__func__);
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8853 if(NULL == pWdaParams)
8854 {
8855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8856 "%s: pWdaParams received NULL", __func__);
8857 VOS_ASSERT(0);
8858 return;
8859 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8860 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8861 if (IS_WDI_STATUS_FAILURE(status))
8862 {
8863 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8864 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8865
8866 pWDA->failureCounts.exitImpsFailureCount++;
8867 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8868 pWDA->failureCounts.exitImpsFailureCount)
8869 {
8870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8871 "%s: wdiStatus %d fail count %d", __func__,
8872 status,
8873 pWDA->failureCounts.exitImpsFailureCount);
8874 pWDA->failureCounts.exitImpsFailureCount = 0;
8875 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8876 WLAN_LOG_INDICATOR_HOST_DRIVER,
8877 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
8878 FALSE, TRUE);
8879 }
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8880 if (WDI_STATUS_DEV_INTERNAL_FAILURE == status)
8881 {
8882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8883 FL("reload wlan driver"));
8884 wpalWlanReload();
8885 }
8886 }
8887 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8888}
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8890/*
8891 * FUNCTION: WDA_ProcessExitImpsReq
8892 * Request to WDI to Exit IMPS power state.
8893 */
8894VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
8895{
8896 WDI_Status status = WDI_STATUS_SUCCESS ;
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8897 tWDA_ReqParams *pWdaParams;
8898 WDI_ExitImpsReqParamsType *wdiExitImpsReqParams;
8899
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8901 "------> %s " ,__func__);
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8902 wdiExitImpsReqParams = (WDI_ExitImpsReqParamsType *)vos_mem_malloc(
8903 sizeof(WDI_ExitImpsReqParamsType));
8904 if (NULL == wdiExitImpsReqParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8905 {
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]8906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8907 "%s: VOS MEM Alloc Failure", __func__);
8908 VOS_ASSERT(0);
8909 return VOS_STATUS_E_NOMEM;
8910 }
8911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8912 if(NULL == pWdaParams)
8913 {
8914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8915 "%s: VOS MEM Alloc Failure", __func__);
8916 VOS_ASSERT(0);
8917 vos_mem_free(wdiExitImpsReqParams);
8918 return VOS_STATUS_E_NOMEM;
8919 }
8920 wdiExitImpsReqParams->wdiReqStatusCB = WDA_ExitImpsReqCallback;
8921 wdiExitImpsReqParams->pUserData = pWdaParams;
8922
8923 /* Store param pointer as passed in by caller */
8924 /* store Params pass it to WDI */
8925 pWdaParams->wdaWdiApiMsgParam = wdiExitImpsReqParams;
8926 pWdaParams->pWdaContext = pWDA;
8927 pWdaParams->wdaMsgParam = wdiExitImpsReqParams;
8928 status = WDI_ExitImpsReq(wdiExitImpsReqParams,
8929 (WDI_ExitImpsRspCb)WDA_ExitImpsRespCallback,
8930 pWdaParams);
8931 if (IS_WDI_STATUS_FAILURE(status))
8932 {
8933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8934 "Failure in Exit IMPS REQ WDI API, free all the memory " );
8935 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8936 vos_mem_free(pWdaParams);
8937 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8938 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8939 return CONVERT_WDI2VOS_STATUS(status) ;
8940}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8941/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8942 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8943 * send Enter BMPS RSP back to PE
8944 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8945void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8946{
8947 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8948 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8949 tEnterBmpsParams *pEnterBmpsRspParams;
8950
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8952 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8953 if(NULL == pWdaParams)
8954 {
8955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8956 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8957 VOS_ASSERT(0) ;
8958 return ;
8959 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8960
8961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8962 if (NULL == pWDA)
8963 {
8964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8965 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]8966
8967 if(pWdaParams->wdaWdiApiMsgParam)
8968 {
8969 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8970 }
8971 vos_mem_free(pWdaParams);
8972
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8973 VOS_ASSERT(0);
8974 return ;
8975 }
8976
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8977 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8978
8979 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8980 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8981
8982 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8983 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]8984 if (eHAL_STATUS_SUCCESS != pEnterBmpsRspParams->status)
8985 {
8986 pWDA->failureCounts.enterBmpsFailureCount++;
8987 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8988 pWDA->failureCounts.enterBmpsFailureCount)
8989 {
8990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8991 "%s: wdiStatus %d fail count %d", __func__,
8992 pwdiEnterBmpsRsp->wdiStatus,
8993 pWDA->failureCounts.enterBmpsFailureCount);
8994 pWDA->failureCounts.enterBmpsFailureCount = 0;
8995 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8996 WLAN_LOG_INDICATOR_HOST_DRIVER,
8997 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
8998 FALSE, TRUE);
8999 }
9000 }
9001 else
9002 {
9003 pWDA->failureCounts.enterBmpsFailureCount = 0;
9004 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9005 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
9006
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9007 return ;
9008}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9009/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9010 * FUNCTION: WDA_EnterBmpsReqCallback
9011 * Free memory and send Enter BMPS RSP back to PE.
9012 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
9013 */
9014void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
9015{
9016 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9017 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9018 tEnterBmpsParams *pEnterBmpsRspParams;
9019
9020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9021 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9022
9023 if(NULL == pWdaParams)
9024 {
9025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9026 "%s: pWdaParams received NULL", __func__);
9027 VOS_ASSERT(0);
9028 return;
9029 }
9030
9031 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9032 if (NULL == pWDA)
9033 {
9034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9035 "%s:pWDA is NULL", __func__);
9036 VOS_ASSERT(0);
9037 return ;
9038 }
9039
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9040 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
9041 pEnterBmpsRspParams->status = wdiStatus;
9042
9043 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9044 {
9045 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9046 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]9047 pWDA->failureCounts.enterBmpsFailureCount++;
9048 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9049 pWDA->failureCounts.enterBmpsFailureCount)
9050 {
9051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9052 "%s: wdiStatus %d fail count %d", __func__,
9053 wdiStatus,
9054 pWDA->failureCounts.enterBmpsFailureCount);
9055 pWDA->failureCounts.enterBmpsFailureCount = 0;
9056 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9057 WLAN_LOG_INDICATOR_HOST_DRIVER,
9058 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
9059 FALSE, TRUE);
9060 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9061 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
9062 }
9063
9064 return;
9065}
9066/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9067 * FUNCTION: WDA_ProcessEnterBmpsReq
9068 * Request to WDI to Enter BMPS power state.
9069 */
9070VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
9071 tEnterBmpsParams *pEnterBmpsReqParams)
9072{
9073 WDI_Status status = WDI_STATUS_SUCCESS;
9074 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
9075 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9077 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9078 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
9079 {
9080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9081 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9082 VOS_ASSERT(0);
9083 return VOS_STATUS_E_FAILURE;
9084 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9085 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
9086 if (NULL == wdiEnterBmpsReqParams)
9087 {
9088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9089 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9090 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9091 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
9092 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9093 return VOS_STATUS_E_NOMEM;
9094 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9095 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
9096 if (NULL == pWdaParams)
9097 {
9098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9099 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9100 VOS_ASSERT(0);
9101 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9102 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
9103 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9104 return VOS_STATUS_E_NOMEM;
9105 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9106 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
9107 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
9108 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
9109 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]9110 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9111 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
9112 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
9113 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9114 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
9115 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9116
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9117 /* Store param pointer as passed in by caller */
9118 /* store Params pass it to WDI */
9119 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9120 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9121 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9122 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9123 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9124 if (IS_WDI_STATUS_FAILURE(status))
9125 {
9126 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9127 "Failure in Enter BMPS REQ WDI API, free all the memory" );
9128 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9129 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9130 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9131 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9132 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9133 return CONVERT_WDI2VOS_STATUS(status);
9134}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9135
9136
9137static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
9138 WDI_Status wdiStatus,
9139 tExitBmpsParams *pExitBmpsReqParams)
9140{
9141 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
9142
9143 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
9144}
9145
9146
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9147/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9148 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9149 * send Exit BMPS RSP back to PE
9150 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9151void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9152{
9153 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9154 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9155 tExitBmpsParams *pExitBmpsRspParams;
9156
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9158 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9159 if(NULL == pWdaParams)
9160 {
9161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9162 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9163 VOS_ASSERT(0) ;
9164 return ;
9165 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9166
9167 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9168 if (NULL == pWDA)
9169 {
9170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9171 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]9172
9173 if(pWdaParams->wdaWdiApiMsgParam)
9174 {
9175 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9176 }
9177 vos_mem_free(pWdaParams);
9178
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9179 VOS_ASSERT(0);
9180 return ;
9181 }
9182
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9183 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
9184
9185 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9186 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9187
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9188 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]9189 vos_mem_free(pWdaParams);
9190
9191 if (WDI_STATUS_SUCCESS != pwdiExitBmpsRsp->wdiStatus)
9192 {
9193 pWDA->failureCounts.exitBmpsFailureCount++;
9194 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9195 pWDA->failureCounts.exitBmpsFailureCount)
9196 {
9197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9198 "%s: Status %d fail count %d", __func__,
9199 pExitBmpsRspParams->status,
9200 pWDA->failureCounts.exitBmpsFailureCount);
9201 pWDA->failureCounts.exitBmpsFailureCount = 0;
9202 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9203 WLAN_LOG_INDICATOR_HOST_DRIVER,
9204 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9205 FALSE, TRUE);
9206 }
9207 }
9208 else
9209 {
9210 pWDA->failureCounts.exitBmpsFailureCount = 0;
9211 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9212
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9213 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9214 return ;
9215}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9216/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9217 * FUNCTION: WDA_ExitBmpsReqCallback
9218 * Free memory and send Exit BMPS RSP back to PE.
9219 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
9220 */
9221void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
9222{
9223 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9224 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9225 tExitBmpsParams *pExitBmpsRspParams;
9226
9227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9228 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9229
9230 if(NULL == pWdaParams)
9231 {
9232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9233 "%s: pWdaParams received NULL", __func__);
9234 VOS_ASSERT(0);
9235 return;
9236 }
9237
9238 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9239 if (NULL == pWDA)
9240 {
9241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9242 "%s:pWDA is NULL", __func__);
9243 VOS_ASSERT(0);
9244 return ;
9245 }
9246
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9247 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
9248 pExitBmpsRspParams->status = wdiStatus;
9249
9250 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9251 {
9252 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9253 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]9254 pWDA->failureCounts.exitBmpsFailureCount++;
9255 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9256 pWDA->failureCounts.exitBmpsFailureCount)
9257 {
9258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9259 "%s: wdiStatus %d fail count %d", __func__,
9260 wdiStatus,
9261 pWDA->failureCounts.exitBmpsFailureCount);
9262 pWDA->failureCounts.exitBmpsFailureCount = 0;
9263 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9264 WLAN_LOG_INDICATOR_HOST_DRIVER,
9265 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9266 FALSE, TRUE);
9267 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9268 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
9269 }
9270
9271 return;
9272}
9273/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9274 * FUNCTION: WDA_ProcessExitBmpsReq
9275 * Request to WDI to Exit BMPS power state.
9276 */
9277VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
9278 tExitBmpsParams *pExitBmpsReqParams)
9279{
9280 WDI_Status status = WDI_STATUS_SUCCESS ;
9281 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
9282 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
9283 sizeof(WDI_ExitBmpsReqParamsType)) ;
9284 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9286 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9287 if(NULL == wdiExitBmpsReqParams)
9288 {
9289 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9290 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9291 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9292 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9293 return VOS_STATUS_E_NOMEM;
9294 }
9295 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9296 if(NULL == pWdaParams)
9297 {
9298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9299 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9300 VOS_ASSERT(0);
9301 vos_mem_free(wdiExitBmpsReqParams);
9302 return VOS_STATUS_E_NOMEM;
9303 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9304 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]9305
9306 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
9307
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9308 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
9309 wdiExitBmpsReqParams->pUserData = pWdaParams;
9310
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9311 /* Store param pointer as passed in by caller */
9312 /* store Params pass it to WDI */
9313 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
9314 pWdaParams->pWdaContext = pWDA;
9315 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9316 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9317 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9318 if(IS_WDI_STATUS_FAILURE(status))
9319 {
9320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9321 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9322 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9323 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9324 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9325 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9326 return CONVERT_WDI2VOS_STATUS(status) ;
9327}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9328/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9329 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9330 * send Enter UAPSD RSP back to PE
9331 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9332void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9333{
9334 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9335 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9336 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9338 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9339 if(NULL == pWdaParams)
9340 {
9341 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9342 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9343 VOS_ASSERT(0) ;
9344 return ;
9345 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9346
9347 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9348 if (NULL == pWDA)
9349 {
9350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9351 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]9352
9353 if(pWdaParams->wdaWdiApiMsgParam)
9354 {
9355 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9356 }
9357 vos_mem_free(pWdaParams);
9358
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9359 VOS_ASSERT(0);
9360 return ;
9361 }
9362
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9363 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
9364
9365 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9366 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9367
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9368 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9369 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9370 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9371 return ;
9372}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9373/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9374 * FUNCTION: WDA_EnterUapsdReqCallback
9375 * Free memory and send Enter UAPSD RSP back to PE.
9376 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
9377 */
9378void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
9379{
9380 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9381 tWDA_CbContext *pWDA;
9382 tUapsdParams *pEnterUapsdRsqParams;
9383
9384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9385 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9386
9387 if(NULL == pWdaParams)
9388 {
9389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9390 "%s: pWdaParams received NULL", __func__);
9391 VOS_ASSERT(0);
9392 return;
9393 }
9394
9395 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9396 if (NULL == pWDA)
9397 {
9398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9399 "%s:pWDA is NULL", __func__);
9400 VOS_ASSERT(0);
9401 return ;
9402 }
9403
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9404 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
9405 pEnterUapsdRsqParams->status = wdiStatus;
9406
9407 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9408 {
9409 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9410 vos_mem_free(pWdaParams);
9411 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
9412 }
9413
9414 return;
9415}
9416/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9417 * FUNCTION: WDA_ProcessEnterUapsdReq
9418 * Request to WDI to Enter UAPSD power state.
9419 */
9420VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
9421 tUapsdParams *pEnterUapsdReqParams)
9422{
9423 WDI_Status status = WDI_STATUS_SUCCESS ;
9424 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
9425 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
9426 sizeof(WDI_EnterUapsdReqParamsType)) ;
9427 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9429 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9430 if(NULL == wdiEnterUapsdReqParams)
9431 {
9432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9433 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9434 VOS_ASSERT(0);
9435 return VOS_STATUS_E_NOMEM;
9436 }
9437 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9438 if(NULL == pWdaParams)
9439 {
9440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9441 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9442 VOS_ASSERT(0);
9443 vos_mem_free(wdiEnterUapsdReqParams);
9444 return VOS_STATUS_E_NOMEM;
9445 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9446 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
9447 pEnterUapsdReqParams->beDeliveryEnabled;
9448 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
9449 pEnterUapsdReqParams->beTriggerEnabled;
9450 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
9451 pEnterUapsdReqParams->bkDeliveryEnabled;
9452 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
9453 pEnterUapsdReqParams->bkTriggerEnabled;
9454 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
9455 pEnterUapsdReqParams->viDeliveryEnabled;
9456 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
9457 pEnterUapsdReqParams->viTriggerEnabled;
9458 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
9459 pEnterUapsdReqParams->voDeliveryEnabled;
9460 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
9461 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]9462 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9463
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9464 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
9465 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9466
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9467 /* Store param pointer as passed in by caller */
9468 /* store Params pass it to WDI */
9469 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
9470 pWdaParams->pWdaContext = pWDA;
9471 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9472 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9473 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9474 if(IS_WDI_STATUS_FAILURE(status))
9475 {
9476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9477 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
9478 vos_mem_free(pWdaParams->wdaMsgParam) ;
9479 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9480 vos_mem_free(pWdaParams) ;
9481 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9482 return CONVERT_WDI2VOS_STATUS(status) ;
9483}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9484/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9485 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9486 * send Exit UAPSD RSP back to PE
9487 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9488void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9489{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9490
9491 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9492 tWDA_CbContext *pWDA;
9493 tExitUapsdParams *pExitUapsdRspParams;
9494
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9496 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9497 if(NULL == pWdaParams)
9498 {
9499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9500 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9501 VOS_ASSERT(0);
9502 return;
9503 }
9504
9505 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
9506 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
9507
9508 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9509 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9510
9511 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9512 vos_mem_free(pWdaParams) ;
9513
9514 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9515 return ;
9516}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9517/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9518 * FUNCTION: WDA_ExitUapsdReqCallback
9519 * Free memory and send Exit UAPSD RSP back to PE.
9520 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
9521 */
9522void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
9523{
9524 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9525 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9526 tExitUapsdParams *pExitUapsdRspParams;
9527
9528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9529 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9530
9531 if(NULL == pWdaParams)
9532 {
9533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9534 "%s: pWdaParams received NULL", __func__);
9535 VOS_ASSERT(0);
9536 return;
9537 }
9538
9539 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9540 if (NULL == pWDA)
9541 {
9542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9543 "%s:pWDA is NULL", __func__);
9544 VOS_ASSERT(0);
9545 return ;
9546 }
9547
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9548 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
9549 pExitUapsdRspParams->status = wdiStatus;
9550
9551 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9552 {
9553 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9554 vos_mem_free(pWdaParams);
9555 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
9556 }
9557
9558 return;
9559}
9560/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9561 * FUNCTION: WDA_ProcessExitUapsdReq
9562 * Request to WDI to Exit UAPSD power state.
9563 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9564VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
9565 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9566{
9567 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9568 tWDA_ReqParams *pWdaParams ;
9569 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
9570 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
9571 sizeof(WDI_ExitUapsdReqParamsType)) ;
9572
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9574 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9575
9576 if(NULL == wdiExitUapsdReqParams)
9577 {
9578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9579 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9580 VOS_ASSERT(0);
9581 return VOS_STATUS_E_NOMEM;
9582 }
9583 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9584 if(NULL == pWdaParams)
9585 {
9586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9587 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9588 VOS_ASSERT(0);
9589 vos_mem_free(wdiExitUapsdReqParams);
9590 return VOS_STATUS_E_NOMEM;
9591 }
9592
9593 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9594 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
9595 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9596
9597 /* Store param pointer as passed in by caller */
9598 /* store Params pass it to WDI */
9599 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
9600 pWdaParams->pWdaContext = pWDA;
9601 pWdaParams->wdaMsgParam = pExitUapsdParams;
9602
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9603 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9604 if(IS_WDI_STATUS_FAILURE(status))
9605 {
9606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9607 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9608 vos_mem_free(pWdaParams->wdaMsgParam) ;
9609 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9610 vos_mem_free(pWdaParams) ;
9611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9612 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 return CONVERT_WDI2VOS_STATUS(status) ;
9614}
9615
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9616/*
9617 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
9618 *
9619 */
9620void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
9621{
9622 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9624 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9625 if(NULL == pWdaParams)
9626 {
9627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9628 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629 VOS_ASSERT(0) ;
9630 return ;
9631 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9632 if( pWdaParams != NULL )
9633 {
9634 if( pWdaParams->wdaWdiApiMsgParam != NULL )
9635 {
9636 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9637 }
9638 if( pWdaParams->wdaMsgParam != NULL )
9639 {
9640 vos_mem_free(pWdaParams->wdaMsgParam) ;
9641 }
9642 vos_mem_free(pWdaParams) ;
9643 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9644 return ;
9645}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9646/*
9647 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
9648 * Request to WDI to set the power save params at start.
9649 */
9650VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
9651 tSirPowerSaveCfg *pPowerSaveCfg)
9652{
9653 WDI_Status status = WDI_STATUS_SUCCESS ;
9654 tHalCfg *tlvStruct = NULL ;
9655 tANI_U8 *tlvStructStart = NULL ;
9656 v_PVOID_t *configParam;
9657 tANI_U32 configParamSize;
9658 tANI_U32 *configDataValue;
9659 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
9660 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9662 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9663 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
9664 {
9665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9666 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9667 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9668 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9669 return VOS_STATUS_E_FAILURE;
9670 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9671 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
9672 if (NULL == wdiPowerSaveCfg)
9673 {
9674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9675 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9676 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9677 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9678 return VOS_STATUS_E_NOMEM;
9679 }
9680 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9681 if(NULL == pWdaParams)
9682 {
9683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9684 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9685 VOS_ASSERT(0);
9686 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9687 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9688 return VOS_STATUS_E_NOMEM;
9689 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9690 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
9691 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9692 if(NULL == configParam)
9693 {
9694 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9695 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9696 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9697 vos_mem_free(pWdaParams);
9698 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9699 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9700 return VOS_STATUS_E_NOMEM;
9701 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9702 vos_mem_set(configParam, configParamSize, 0);
9703 wdiPowerSaveCfg->pConfigBuffer = configParam;
9704 tlvStruct = (tHalCfg *)configParam;
9705 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9706 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
9707 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
9708 tlvStruct->length = sizeof(tANI_U32);
9709 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9710 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9711 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9712 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9713 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
9714 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
9715 tlvStruct->length = sizeof(tANI_U32);
9716 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9717 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9718 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9719 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9720 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
9721 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
9722 tlvStruct->length = sizeof(tANI_U32);
9723 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9724 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9725 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9726 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9727 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
9728 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
9729 tlvStruct->length = sizeof(tANI_U32);
9730 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9731 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9732 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9733 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9734 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
9735 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
9736 tlvStruct->length = sizeof(tANI_U32);
9737 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9738 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9739 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9740 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9741 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
9742 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
9743 tlvStruct->length = sizeof(tANI_U32);
9744 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9745 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9746 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9747 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9748 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
9749 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
9750 tlvStruct->length = sizeof(tANI_U32);
9751 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9752 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9755 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
9756 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
9757 tlvStruct->length = sizeof(tANI_U32);
9758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9759 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
9760 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9761 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9762 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
9763 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
9764 tlvStruct->length = sizeof(tANI_U32);
9765 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9766 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
9767 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9768 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9769 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
9770 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
9771 tlvStruct->length = sizeof(tANI_U32);
9772 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9773 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9774 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9775 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9776 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
9777 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
9778 tlvStruct->length = sizeof(tANI_U32);
9779 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9780 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9781 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9782 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9783 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9784 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9785 /* store Params pass it to WDI */
9786 pWdaParams->wdaMsgParam = configParam;
9787 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
9788 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9789 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
9790 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9791 if(IS_WDI_STATUS_FAILURE(status))
9792 {
9793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9794 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
9795 vos_mem_free(pWdaParams->wdaMsgParam);
9796 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9797 vos_mem_free(pWdaParams);
9798 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9799 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9800 return CONVERT_WDI2VOS_STATUS(status);
9801}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9802/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9803 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9804 *
9805 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9806void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9807{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9808 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9809
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9811 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9812
9813 if(NULL == pWdaParams)
9814 {
9815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9816 "%s: pWdaParams received NULL", __func__);
9817 VOS_ASSERT(0);
9818 return ;
9819 }
9820
9821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9822 vos_mem_free(pWdaParams);
9823
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9824 return ;
9825}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9826/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9827 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
9828 * Free memory.
9829 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
9830 */
9831void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
9832{
9833 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9834
9835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9836 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9837
9838 if(NULL == pWdaParams)
9839 {
9840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9841 "%s: pWdaParams received NULL", __func__);
9842 VOS_ASSERT(0);
9843 return;
9844 }
9845
9846 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9847 {
9848 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9849 vos_mem_free(pWdaParams);
9850 }
9851
9852 return;
9853}
9854/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9855 * FUNCTION: WDA_SetUapsdAcParamsReq
9856 * Request to WDI to set the UAPSD params for an ac (sta mode).
9857 */
9858VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
9859 tUapsdInfo *pUapsdInfo)
9860{
9861 WDI_Status status = WDI_STATUS_SUCCESS;
9862 tWDA_CbContext *pWDA = NULL ;
9863 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
9864 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
9865 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
9866 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9868 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9869 if(NULL == wdiUapsdParams)
9870 {
9871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9872 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9873 VOS_ASSERT(0);
9874 return VOS_STATUS_E_NOMEM;
9875 }
9876 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9877 if(NULL == pWdaParams)
9878 {
9879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9880 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9881 VOS_ASSERT(0);
9882 vos_mem_free(wdiUapsdParams);
9883 return VOS_STATUS_E_NOMEM;
9884 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9885 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
9886 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
9887 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
9888 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
9889 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
9890 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9891 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
9892 wdiUapsdParams->pUserData = pWdaParams;
9893
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9894 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9895 pWdaParams->pWdaContext = pWDA;
9896 /* Store param pointer as passed in by caller */
9897 pWdaParams->wdaMsgParam = pUapsdInfo;
9898 /* store Params pass it to WDI */
9899 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9900 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9901 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9902 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9903 if(IS_WDI_STATUS_FAILURE(status))
9904 {
9905 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9906 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
9907 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9908 vos_mem_free(pWdaParams);
9909 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9910 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
9911 return VOS_STATUS_SUCCESS;
9912 else
9913 return VOS_STATUS_E_FAILURE;
9914
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9915}
9916/*
9917 * FUNCTION: WDA_ClearUapsdAcParamsReq
9918 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
9919 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
9920 * and again enter the UPASD with the modified params. Hence the disable
9921 * function was kept empty.
9922 *
9923 */
9924VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
9925{
9926 /* do nothing */
9927 return VOS_STATUS_SUCCESS;
9928}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9929/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9930 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9931 *
9932 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9933void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9934{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9935 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9936
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9938 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9939
9940 if(NULL == pWdaParams)
9941 {
9942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9943 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9944 VOS_ASSERT(0) ;
9945 return ;
9946 }
9947
9948 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9949 vos_mem_free(pWdaParams->wdaMsgParam);
9950 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9951
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9952 //print a msg, nothing else to do
9953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9954 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9955 return ;
9956}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9957/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9958 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
9959 * Free memory.
9960 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
9961 */
9962void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
9963{
9964 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9965
9966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9967 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9968
9969 if(NULL == pWdaParams)
9970 {
9971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9972 "%s: pWdaParams received NULL", __func__);
9973 VOS_ASSERT(0);
9974 return;
9975 }
9976
9977 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9978 {
9979 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9980 vos_mem_free(pWdaParams->wdaMsgParam);
9981 vos_mem_free(pWdaParams);
9982 }
9983
9984 return;
9985}
9986/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9987 * FUNCTION: WDA_UpdateUapsdParamsReq
9988 * Request to WDI to update UAPSD params (in softAP mode) for a station.
9989 */
9990VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
9991 tUpdateUapsdParams* pUpdateUapsdInfo)
9992{
9993 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9994 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9995 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
9996 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
9997 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9998 tWDA_ReqParams *pWdaParams = NULL;
9999
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10001 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10002 if(NULL == wdiUpdateUapsdParams)
10003 {
10004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10005 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10006 VOS_ASSERT(0);
10007 return VOS_STATUS_E_NOMEM;
10008 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10009 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
10010 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
10011 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10012 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
10013 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10014
10015 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10016 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10017 {
10018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10019 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10020 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10021 vos_mem_free(pUpdateUapsdInfo);
10022 vos_mem_free(wdiUpdateUapsdParams);
10023 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10024 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10025 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10026 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10027 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10028 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
10029 pWdaParams->pWdaContext = pWDA;
10030
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10031 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10032 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10033 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10034
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10035 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10036 {
10037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10038 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10039 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
10040 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10041 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]10042 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10043 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10044 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10045}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10046/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10047 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10048 *
10049 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10050void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10051{
10052 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10054 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10055 if(WDI_STATUS_SUCCESS != wdiStatus)
10056 {
10057 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]10058 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10060 if(NULL == pWdaParams)
10061 {
10062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10063 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10064 VOS_ASSERT(0) ;
10065 return ;
10066 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10068 vos_mem_free(pWdaParams->wdaMsgParam);
10069 vos_mem_free(pWdaParams);
10070 return ;
10071}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10072/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10073 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
10074 * Free memory.
10075 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
10076 */
10077void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
10078{
10079 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10080
10081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10082 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10083
10084 if(NULL == pWdaParams)
10085 {
10086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10087 "%s: pWdaParams received NULL", __func__);
10088 VOS_ASSERT(0);
10089 return;
10090 }
10091
10092 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10093 {
10094 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10095 vos_mem_free(pWdaParams->wdaMsgParam);
10096 vos_mem_free(pWdaParams);
10097 }
10098
10099 return;
10100}
10101/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10102 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
10103 *
10104 */
10105VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
10106 tSirWlanSetRxpFilters *pWlanSuspendParam)
10107{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10108 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10109 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]10110 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10111 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]10112 /* Sanity Check
10113 * This is very unlikely and add assert to collect more info next time */
10114 if(NULL == pWlanSuspendParam)
10115 {
10116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10117 "%s: pWlanSuspendParam received NULL", __func__);
10118 VOS_ASSERT(0) ;
10119 return VOS_STATUS_E_FAULT;
10120 }
10121 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
10122 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10124 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10125 if(NULL == wdiRxpFilterParams)
10126 {
10127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10128 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10129 VOS_ASSERT(0);
10130 vos_mem_free(pWlanSuspendParam);
10131 return VOS_STATUS_E_NOMEM;
10132 }
10133 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10134 if(NULL == pWdaParams)
10135 {
10136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10137 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10138 VOS_ASSERT(0);
10139 vos_mem_free(wdiRxpFilterParams);
10140 vos_mem_free(pWlanSuspendParam);
10141 return VOS_STATUS_E_NOMEM;
10142 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10143 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
10144 pWlanSuspendParam->setMcstBcstFilter;
10145 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
10146 pWlanSuspendParam->configuredMcstBcstFilterSetting;
10147
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10148 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
10149 wdiRxpFilterParams->pUserData = pWdaParams;
10150
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10151 pWdaParams->pWdaContext = pWDA;
10152 pWdaParams->wdaMsgParam = pWlanSuspendParam;
10153 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10154 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10155 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10156 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10157 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10158 {
10159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10160 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10161 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10162 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10163 vos_mem_free(pWdaParams->wdaMsgParam);
10164 vos_mem_free(pWdaParams);
10165 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10166 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10167}
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10168
10169/*
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10170 * FUNCTION: WDA_ProcessGetFrameLogReq
10171 * Request to WDI to get the Frame Log.
10172 */
10173VOS_STATUS WDA_ProcessGetFrameLogReq(tWDA_CbContext *pWDA,
10174 tAniGetFrameLogReq *pGetFrameLog)
10175{
10176 VOS_STATUS status = VOS_STATUS_SUCCESS;
10177 WDI_Status wstatus;
10178 WDI_GetFrameLogReqInfoType *wdiGetFrameLogInfo;
10179 tWDA_ReqParams *pWdaParams ;
10180
10181 /* Sanity Check*/
10182 if(NULL == pGetFrameLog)
10183 {
10184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10185 "%s: pFWLoggingInitParam received NULL", __func__);
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10186 VOS_ASSERT(0) ;
10187 return VOS_STATUS_E_FAULT;
10188 }
10189
10190 wdiGetFrameLogInfo = (WDI_GetFrameLogReqInfoType *)vos_mem_malloc(
10191 sizeof(WDI_GetFrameLogReqInfoType));
10192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10193 "------> %s " ,__func__);
10194
10195 if(NULL == wdiGetFrameLogInfo)
10196 {
10197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10198 "%s: VOS MEM Alloc Failure", __func__);
10199 VOS_ASSERT(0);
10200 vos_mem_free(pGetFrameLog);
10201 return VOS_STATUS_E_NOMEM;
10202 }
10203
10204 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
10205 if(NULL == pWdaParams)
10206 {
10207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10208 "%s: VOS MEM Alloc Failure", __func__);
10209 VOS_ASSERT(0);
10210 vos_mem_free(wdiGetFrameLogInfo);
10211 vos_mem_free(pGetFrameLog);
10212 return VOS_STATUS_E_NOMEM;
10213 }
10214
10215 wdiGetFrameLogInfo->flags = pGetFrameLog->getFrameLogCmdFlag;
10216
10217 pWdaParams->pWdaContext = pWDA;
10218 pWdaParams->wdaMsgParam = pGetFrameLog;
10219 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGetFrameLogInfo;
10220
10221 wstatus = WDI_GetFrameLogReq(wdiGetFrameLogInfo,
10222 (WDI_GetFrameLogRspCb)WDA_GetFrameLogRspCallback,
10223 pWdaParams);
10224 if(IS_WDI_STATUS_FAILURE(wstatus))
10225 {
10226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10227 "Failure in get frame log REQ WDI API, free all the memory" );
10228 status = CONVERT_WDI2VOS_STATUS(wstatus);
10229 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10230 vos_mem_free(pWdaParams->wdaMsgParam);
10231 vos_mem_free(pWdaParams);
10232 }
10233 return status;
10234}
10235
Sachin Ahuja715aafc2015-07-21 23:35:10 +0530[diff] [blame]10236
10237/*
10238 * FUNCTION: WDA_FatalEventLogsRspCallback
10239 * recieves Flush Logs response from FW
10240 */
10241
10242void WDA_FatalEventLogsRspCallback(WDI_FatalEventLogsRspParamType* wdiRsp,
10243 void* pUserData)
10244{
10245 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10246
10247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10248 "<------ %s,wdiStatus:%d " ,
10249 __func__, wdiRsp->wdiStatus);
10250 if(NULL == pWdaParams)
10251 {
10252 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10253 "%s: pWdaParams received NULL", __func__);
10254 VOS_ASSERT(0);
10255 return ;
10256 }
10257
10258 if(NULL == pWdaParams->wdaMsgParam)
10259 {
10260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10261 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
10262 VOS_ASSERT(0);
10263 vos_mem_free(pWdaParams);
10264 return ;
10265 }
10266
10267 if(IS_WDI_STATUS_FAILURE(wdiRsp->wdiStatus))
10268 {
10269 /*
10270 * If it is failure, it means JOb is already posted by FW
10271 * for logging, so for failure scenario also we will get the
10272 * done indication
10273 */
10274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10275 "%s: Fatal Event Rsp Failure,wdiStatus : %d ",
10276 __func__, wdiRsp->wdiStatus);
10277 }
10278
10279 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10280 vos_mem_free(pWdaParams->wdaMsgParam);
10281 vos_mem_free(pWdaParams);
10282
10283 return;
10284
10285}
10286
10287/*
10288 * FUNCTION: WDA_ProcessFatalEventLogsReq
10289 * Request to WDI to send the fatal Event Logs Req.
10290 */
10291
10292VOS_STATUS WDA_ProcessFatalEventLogsReq(tWDA_CbContext *pWDA,
10293 tSirFatalEventLogsReqParam *pFatalEventLogsReqParam)
10294{
10295 VOS_STATUS status = VOS_STATUS_SUCCESS;
10296 WDI_FatalEventLogsReqInfoType *wdiFatalEventLogsReqInfo;
10297 tWDA_ReqParams *pWdaParams ;
10298 WDI_Status wstatus;
10299
10300
10301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10302 "------> %s " ,__func__);
10303 if (NULL == pFatalEventLogsReqParam)
10304 {
10305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10306 "%s: pMgmtLoggingInitParam received NULL", __func__);
10307 VOS_ASSERT(0) ;
10308 return VOS_STATUS_E_FAULT;
10309 }
10310 wdiFatalEventLogsReqInfo = (WDI_FatalEventLogsReqInfoType *)vos_mem_malloc(
10311 sizeof(WDI_FatalEventLogsReqInfoType));
10312 if(NULL == wdiFatalEventLogsReqInfo)
10313 {
10314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10315 "%s: VOS MEM Alloc Failure", __func__);
10316 VOS_ASSERT(0);
10317 vos_mem_free(pFatalEventLogsReqParam);
10318 return VOS_STATUS_E_NOMEM;
10319 }
10320 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10321 if(NULL == pWdaParams)
10322 {
10323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10324 "%s: VOS MEM Alloc Failure", __func__);
10325 VOS_ASSERT(0);
10326 vos_mem_free(wdiFatalEventLogsReqInfo);
10327 vos_mem_free(pFatalEventLogsReqParam);
10328 return VOS_STATUS_E_NOMEM;
10329 }
10330 wdiFatalEventLogsReqInfo->reason_code = pFatalEventLogsReqParam->reason_code;
10331 pWdaParams->pWdaContext = pWDA;
10332 pWdaParams->wdaMsgParam = pFatalEventLogsReqParam;
10333 pWdaParams->wdaWdiApiMsgParam = (void *)wdiFatalEventLogsReqInfo;
10334
10335 wstatus = WDI_FatalEventLogsReq(wdiFatalEventLogsReqInfo,
10336 (WDI_FatalEventLogsRspCb)WDA_FatalEventLogsRspCallback,
10337 pWdaParams);
10338 if(IS_WDI_STATUS_FAILURE(wstatus))
10339 {
10340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10341 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10342 status = CONVERT_WDI2VOS_STATUS(wstatus);
10343 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10344 vos_mem_free(pWdaParams->wdaMsgParam);
10345 vos_mem_free(pWdaParams);
10346 }
10347
10348 return status;
10349
10350}
10351
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10352/*
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10353 * FUNCTION: WDA_ProcessFWLoggingInitReq
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10354 *
10355 */
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10356VOS_STATUS WDA_ProcessFWLoggingInitReq(tWDA_CbContext *pWDA,
10357 tSirFWLoggingInitParam *pFWLoggingInitParam)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10358{
10359 VOS_STATUS status = VOS_STATUS_SUCCESS;
10360 WDI_Status wstatus;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10361 WDI_FWLoggingInitReqInfoType *wdiFWLoggingInitInfo;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10362 tWDA_ReqParams *pWdaParams ;
10363
10364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10365 "------> %s " ,__func__);
10366
10367 /* Sanity Check*/
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10368 if(NULL == pFWLoggingInitParam)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10369 {
10370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10371 "%s: pFWLoggingInitParam received NULL", __func__);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10372 VOS_ASSERT(0) ;
10373 return VOS_STATUS_E_FAULT;
10374 }
10375
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10376 wdiFWLoggingInitInfo = (WDI_FWLoggingInitReqInfoType *)vos_mem_malloc(
10377 sizeof(WDI_FWLoggingInitReqInfoType));
10378 if(NULL == wdiFWLoggingInitInfo)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10379 {
10380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10381 "%s: VOS MEM Alloc Failure", __func__);
10382 VOS_ASSERT(0);
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10383 vos_mem_free(pFWLoggingInitParam);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10384 return VOS_STATUS_E_NOMEM;
10385 }
10386
10387 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10388 if(NULL == pWdaParams)
10389 {
10390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10391 "%s: VOS MEM Alloc Failure", __func__);
10392 VOS_ASSERT(0);
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10393 vos_mem_free(wdiFWLoggingInitInfo);
10394 vos_mem_free(pFWLoggingInitParam);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10395 return VOS_STATUS_E_NOMEM;
10396 }
10397
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10398 wdiFWLoggingInitInfo->enableFlag = pFWLoggingInitParam->enableFlag;
10399 wdiFWLoggingInitInfo->frameType = pFWLoggingInitParam->frameType;
10400 wdiFWLoggingInitInfo->frameSize = pFWLoggingInitParam->frameSize;
10401 wdiFWLoggingInitInfo->bufferMode = pFWLoggingInitParam->bufferMode;
10402 wdiFWLoggingInitInfo->continuousFrameLogging =
10403 pFWLoggingInitParam->continuousFrameLogging;
10404 wdiFWLoggingInitInfo->minLogBufferSize=
10405 pFWLoggingInitParam->minLogBufferSize;
10406 wdiFWLoggingInitInfo->maxLogBufferSize=
10407 pFWLoggingInitParam->maxLogBufferSize;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10408
10409 pWdaParams->pWdaContext = pWDA;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10410 pWdaParams->wdaMsgParam = pFWLoggingInitParam;
10411 pWdaParams->wdaWdiApiMsgParam = (void *)wdiFWLoggingInitInfo;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10412
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10413 wstatus = WDI_FWLoggingInitReq(wdiFWLoggingInitInfo,
10414 (WDI_FWLoggingInitRspCb)WDA_FWLoggingInitRspCallback,
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10415 pWdaParams);
10416 if(IS_WDI_STATUS_FAILURE(wstatus))
10417 {
10418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10419 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10420 status = CONVERT_WDI2VOS_STATUS(wstatus);
10421 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10422 vos_mem_free(pWdaParams->wdaMsgParam);
10423 vos_mem_free(pWdaParams);
10424 }
10425
10426 return status;
10427}
10428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10429/*
10430 * FUNCTION: WDA_WdiIndicationCallback
10431 *
10432 */
10433void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
10434 void* pUserData)
10435{
10436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10437 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10438}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10439/*
10440 * FUNCTION: WDA_ProcessWlanSuspendInd
10441 *
10442 */
10443VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
10444 tSirWlanSuspendParam *pWlanSuspendParam)
10445{
10446 WDI_Status wdiStatus;
10447 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10449 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10450 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
10451 pWlanSuspendParam->configuredMcstBcstFilterSetting;
10452 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
10453 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10454 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]10455 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
10456 if(WDI_STATUS_PENDING == wdiStatus)
10457 {
10458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10459 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10460 }
10461 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
10462 {
10463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10464 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10466 vos_mem_free(pWlanSuspendParam);
10467 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10468}
10469
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]10470#ifdef WLAN_FEATURE_11W
10471/*
10472 * FUNCTION: WDA_ProcessExcludeUnecryptInd
10473 *
10474 */
10475VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
10476 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
10477{
10478 WDI_Status wdiStatus;
10479 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
10480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10481 "------> %s ", __func__);
10482
10483 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
10484 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
10485 sizeof(tSirMacAddr));
10486
10487 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
10488 wdiExclUnencryptParams.pUserData = pWDA;
10489
10490 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
10491 if(WDI_STATUS_PENDING == wdiStatus)
10492 {
10493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10494 "Pending received for %s:%d ", __func__, __LINE__ );
10495 }
10496 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
10497 {
10498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10499 "Failure in %s:%d ", __func__, __LINE__ );
10500 }
10501 vos_mem_free(pExclUnencryptParam);
10502 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10503}
10504#endif
10505
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10506/*
10507 * FUNCTION: WDA_ProcessWlanResumeCallback
10508 *
10509 */
10510void WDA_ProcessWlanResumeCallback(
10511 WDI_SuspendResumeRspParamsType *resumeRspParams,
10512 void* pUserData)
10513{
10514 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10516 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10517 if(NULL == pWdaParams)
10518 {
10519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10520 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10521 VOS_ASSERT(0) ;
10522 return ;
10523 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10524 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
10525 {
10526 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]10527 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10528 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10529 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10530 vos_mem_free(pWdaParams->wdaMsgParam);
10531 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10532 return ;
10533}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10534/*
10535 * FUNCTION: WDA_ProcessWlanResumeReq
10536 *
10537 */
10538VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
10539 tSirWlanResumeParam *pWlanResumeParam)
10540{
10541 WDI_Status wdiStatus;
10542 WDI_ResumeParamsType *wdiResumeParams =
10543 (WDI_ResumeParamsType *)vos_mem_malloc(
10544 sizeof(WDI_ResumeParamsType) ) ;
10545 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10547 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10548 if(NULL == wdiResumeParams)
10549 {
10550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10551 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10552 VOS_ASSERT(0);
10553 return VOS_STATUS_E_NOMEM;
10554 }
10555 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10556 if(NULL == pWdaParams)
10557 {
10558 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10559 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10560 VOS_ASSERT(0);
10561 vos_mem_free(wdiResumeParams);
10562 return VOS_STATUS_E_NOMEM;
10563 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10564 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
10565 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10566 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]10567 wdiResumeParams->wdiReqStatusCB = NULL;
10568 pWdaParams->wdaMsgParam = pWlanResumeParam;
10569 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
10570 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10571 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
10572 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
10573 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10574 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10575 {
10576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10577 "Failure in Host Resume REQ WDI API, free all the memory " );
10578 VOS_ASSERT(0);
10579 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10580 vos_mem_free(pWdaParams->wdaMsgParam);
10581 vos_mem_free(pWdaParams);
10582 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10583 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10584}
10585
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10586/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10587 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10588 *
10589 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10590void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10591{
10592 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10594 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10595 if(NULL == pWdaParams)
10596 {
10597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10598 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10599 VOS_ASSERT(0) ;
10600 return ;
10601 }
10602
10603 vos_mem_free(pWdaParams->wdaMsgParam) ;
10604 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10605 vos_mem_free(pWdaParams) ;
10606 /*
10607 * No respone required for SetBeaconFilter req so just free the request
10608 * param here
10609 */
10610
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10611 return ;
10612}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10613/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10614 * FUNCTION: WDA_SetBeaconFilterReqCallback
10615 * Free memory.
10616 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
10617 */
10618void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
10619{
10620 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10621
10622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10623 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10624
10625 if(NULL == pWdaParams)
10626 {
10627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10628 "%s: pWdaParams received NULL", __func__);
10629 VOS_ASSERT(0);
10630 return;
10631 }
10632
10633 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10634 {
10635 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10636 vos_mem_free(pWdaParams->wdaMsgParam);
10637 vos_mem_free(pWdaParams);
10638 }
10639
10640 return;
10641}
10642/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10643 * FUNCTION: WDA_SetBeaconFilterReq
10644 * Request to WDI to send the beacon filtering related information.
10645 */
10646VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
10647 tBeaconFilterMsg* pBeaconFilterInfo)
10648{
10649 WDI_Status status = WDI_STATUS_SUCCESS;
10650 tANI_U8 *dstPtr, *srcPtr;
10651 tANI_U8 filterLength;
10652 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
10653 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
10654 sizeof(WDI_BeaconFilterReqParamsType) ) ;
10655 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10657 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10658 if(NULL == wdiBeaconFilterInfo)
10659 {
10660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10661 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10662 VOS_ASSERT(0);
10663 return VOS_STATUS_E_NOMEM;
10664 }
10665 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10666 if(NULL == pWdaParams)
10667 {
10668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10669 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10670 VOS_ASSERT(0);
10671 vos_mem_free(wdiBeaconFilterInfo);
10672 return VOS_STATUS_E_NOMEM;
10673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10674 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
10675 pBeaconFilterInfo->beaconInterval;
10676 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
10677 pBeaconFilterInfo->capabilityInfo;
10678 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
10679 pBeaconFilterInfo->capabilityMask;
10680 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]10681
10682 //Fill the BssIdx
10683 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
10684
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10685 //Fill structure with info contained in the beaconFilterTable
10686 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
10687 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
10688 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
10689 if(WDI_BEACON_FILTER_LEN < filterLength)
10690 {
10691 filterLength = WDI_BEACON_FILTER_LEN;
10692 }
10693 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10694 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
10695 wdiBeaconFilterInfo->pUserData = pWdaParams;
10696
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10697 /* Store param pointer as passed in by caller */
10698 /* store Params pass it to WDI */
10699 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
10700 pWdaParams->pWdaContext = pWDA;
10701 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
10702
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10703 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10704 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10705 if(IS_WDI_STATUS_FAILURE(status))
10706 {
10707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10708 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
10709 vos_mem_free(pWdaParams->wdaMsgParam) ;
10710 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10711 vos_mem_free(pWdaParams) ;
10712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10713 return CONVERT_WDI2VOS_STATUS(status) ;
10714}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10715/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10716 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10717 *
10718 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10719void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10720{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10721 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
10722
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10724 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10725
10726 if(NULL == pWdaParams)
10727 {
10728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10729 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10730 VOS_ASSERT(0) ;
10731 return ;
10732 }
10733
10734 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10735 vos_mem_free(pWdaParams->wdaMsgParam);
10736 vos_mem_free(pWdaParams);
10737
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10738 //print a msg, nothing else to do
10739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10740 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10741 return ;
10742}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10743/*
10744 * FUNCTION: WDA_RemBeaconFilterReqCallback
10745 * Free memory.
10746 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
10747 */
10748void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
10749{
10750 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10751
10752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10753 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10754
10755 if(NULL == pWdaParams)
10756 {
10757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10758 "%s: pWdaParams received NULL", __func__);
10759 VOS_ASSERT(0);
10760 return;
10761 }
10762
10763 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10764 {
10765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10766 vos_mem_free(pWdaParams->wdaMsgParam);
10767 vos_mem_free(pWdaParams);
10768 }
10769
10770 return;
10771}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10772 // TODO: PE does not have this feature for now implemented,
10773 // but the support for removing beacon filter exists between
10774 // HAL and FW. This function can be called whenever PE defines
10775 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10776/*
10777 * FUNCTION: WDA_RemBeaconFilterReq
10778 * Request to WDI to send the removal of beacon filtering related information.
10779 */
10780VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
10781 tRemBeaconFilterMsg* pBeaconFilterInfo)
10782{
10783 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10784 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10785 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
10786 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
10787 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10788 tWDA_ReqParams *pWdaParams ;
10789
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10791 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10792 if(NULL == wdiBeaconFilterInfo)
10793 {
10794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10795 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10796 VOS_ASSERT(0);
10797 return VOS_STATUS_E_NOMEM;
10798 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10799 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10800 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10801 {
10802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10803 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10804 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10805 vos_mem_free(wdiBeaconFilterInfo);
10806 vos_mem_free(pBeaconFilterInfo);
10807 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10808 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10809
10810 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
10811 pBeaconFilterInfo->ucIeCount;
10812 //Fill structure with info contained in the ucRemIeId
10813 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
10814 pBeaconFilterInfo->ucRemIeId,
10815 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
10816 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
10817 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10818
10819 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10820 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10821 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10822 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
10823
10824 pWdaParams->pWdaContext = pWDA;
10825
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10826 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10827 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10828 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10829 {
10830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10831 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10832 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10833 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10834 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]10835 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10836 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10837 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10838}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10839/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10840 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10841 *
10842 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10843void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10844{
10845 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10846 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10847 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10848 if(NULL == pWdaParams)
10849 {
10850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10851 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10852 VOS_ASSERT(0) ;
10853 return ;
10854 }
10855
10856 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10857 vos_mem_free(pWdaParams) ;
10858
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10859 return ;
10860}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10862 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
10863 * Free memory.
10864 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
10865 */
10866void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
10867{
10868 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10869
10870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10871 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10872
10873 if(NULL == pWdaParams)
10874 {
10875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10876 "%s: pWdaParams received NULL", __func__);
10877 VOS_ASSERT(0);
10878 return;
10879 }
10880
10881 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10882 {
10883 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10884 vos_mem_free(pWdaParams);
10885 }
10886
10887 return;
10888}
10889/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10890 * FUNCTION: WDA_SetRSSIThresholdsReq
10891 * Request to WDI to set the RSSI thresholds (sta mode).
10892 */
10893VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
10894{
10895 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10896 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10897 tWDA_CbContext *pWDA = NULL ;
10898 v_PVOID_t pVosContext = NULL;
10899 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
10900 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
10901 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
10902 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10904 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10905 if(NULL == wdiRSSIThresholdsInfo)
10906 {
10907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10908 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10909 VOS_ASSERT(0);
10910 return VOS_STATUS_E_NOMEM;
10911 }
10912 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10913 if(NULL == pWdaParams)
10914 {
10915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10916 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10917 VOS_ASSERT(0);
10918 vos_mem_free(wdiRSSIThresholdsInfo);
10919 return VOS_STATUS_E_NOMEM;
10920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10921 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10922 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
10923 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
10924 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10925 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
10926 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
10927 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10928 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
10929 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
10930 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10931 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
10932 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10933 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
10934 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
10935
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10936 /* Store param pointer as passed in by caller */
10937 /* store Params pass it to WDI */
10938 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
10939 pWdaParams->pWdaContext = pWDA;
10940 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10941 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10942 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10943 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10944 {
10945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10946 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10947 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10948 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10949 vos_mem_free(pWdaParams) ;
10950 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10951 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10952
10953}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10954/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]10955 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10956 *
10957 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]10958void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10959{
10960 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
10961
10962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10963 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10964 if(NULL == pWdaParams)
10965 {
10966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10967 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10968 VOS_ASSERT(0) ;
10969 return ;
10970 }
10971
10972 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10973 vos_mem_free(pWdaParams->wdaMsgParam);
10974 vos_mem_free(pWdaParams) ;
10975
10976 //print a msg, nothing else to do
10977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]10978 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10979 return ;
10980}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10981/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]10982 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10983 * Free memory.
10984 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]10985 */
10986void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
10987{
10988 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10989
10990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10991 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10992
10993 if(NULL == pWdaParams)
10994 {
10995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10996 "%s: Invalid pWdaParams pointer", __func__);
10997 VOS_ASSERT(0);
10998 return;
10999 }
11000
11001 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11002 {
11003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11004 vos_mem_free(pWdaParams->wdaMsgParam);
11005 vos_mem_free(pWdaParams);
11006 }
11007
11008 return;
11009}
11010/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11011 * FUNCTION: WDA_ProcessHostOffloadReq
11012 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11013 * to broadcast traffic (sta mode).
11014 */
11015VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
11016 tSirHostOffloadReq *pHostOffloadParams)
11017{
11018 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11019 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11020 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
11021 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
11022 sizeof(WDI_HostOffloadReqParamsType)) ;
11023 tWDA_ReqParams *pWdaParams ;
11024
11025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11026 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11027
11028 if(NULL == wdiHostOffloadInfo)
11029 {
11030 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11031 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11032 VOS_ASSERT(0);
11033 return VOS_STATUS_E_NOMEM;
11034 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11035 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11036 if(NULL == pWdaParams)
11037 {
11038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11039 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11040 VOS_ASSERT(0);
11041 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11042 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11043 return VOS_STATUS_E_NOMEM;
11044 }
11045
11046 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
11047 pHostOffloadParams->offloadType;
11048 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
11049 pHostOffloadParams->enableOrDisable;
11050
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11051 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
11052 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
11053
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11054 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
11055 {
11056 case SIR_IPV4_ARP_REPLY_OFFLOAD:
11057 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
11058 pHostOffloadParams->params.hostIpv4Addr,
11059 4);
11060 break;
11061 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
11062 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
11063 pHostOffloadParams->params.hostIpv6Addr,
11064 16);
11065 break;
11066 case SIR_IPV6_NS_OFFLOAD:
11067 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
11068 pHostOffloadParams->params.hostIpv6Addr,
11069 16);
11070
11071#ifdef WLAN_NS_OFFLOAD
11072 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
11073 {
11074 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
11075 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
11076 16);
11077 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
11078 }
11079 else
11080 {
11081 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
11082 }
11083
11084 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
11085 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
11086 16);
11087 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
11088 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
11089 6);
11090
11091 //Only two are supported so let's go through them without a loop
11092 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
11093 {
11094 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
11095 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
11096 16);
11097 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
11098 }
11099 else
11100 {
11101 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
11102 }
11103
11104 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
11105 {
11106 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
11107 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
11108 16);
11109 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
11110 }
11111 else
11112 {
11113 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
11114 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]11115 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
11116 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11117 break;
11118#endif //WLAN_NS_OFFLOAD
11119 default:
11120 {
11121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11122 "No Handling for Offload Type %x in WDA "
11123 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
11124 //WDA_VOS_ASSERT(0) ;
11125 }
11126 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11127 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
11128 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11129
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11130 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11131 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11132 /* store Params pass it to WDI */
11133 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
11134 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11136
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11137 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11138 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11139
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11140 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11141 {
11142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
c_hpothu86feba52014-10-28 15:51:18 +0530[diff] [blame]11143 "Failure in host offload REQ WDI API, free all the memory %d",
11144 wstatus);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11145 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11146 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11147 vos_mem_free(pWdaParams->wdaMsgParam);
11148 vos_mem_free(pWdaParams) ;
11149 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11150 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11151
11152}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11153/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11154 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11155 *
11156 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11157void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11158{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11159 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
11160
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11162 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11163
11164 if(NULL == pWdaParams)
11165 {
11166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11167 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11168 VOS_ASSERT(0) ;
11169 return ;
11170 }
11171
11172 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11173 vos_mem_free(pWdaParams->wdaMsgParam);
11174 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11175
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11176 //print a msg, nothing else to do
11177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11178 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11179 return ;
11180}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11181/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11182 * FUNCTION: WDA_KeepAliveReqCallback
11183 * Free memory.
11184 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
11185 */
11186void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
11187{
11188 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11189
11190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11191 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11192
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 }
11200
11201 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11202 {
11203 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11204 vos_mem_free(pWdaParams->wdaMsgParam);
11205 vos_mem_free(pWdaParams);
11206 }
11207
11208 return;
11209}
11210/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11211 * FUNCTION: WDA_ProcessKeepAliveReq
11212 * Request to WDI to send Keep Alive packets to minimize unnecessary host
11213 * wakeup due to broadcast traffic (sta mode).
11214 */
11215VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
11216 tSirKeepAliveReq *pKeepAliveParams)
11217{
11218 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11219 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11220 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
11221 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
11222 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11223 tWDA_ReqParams *pWdaParams;
11224
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11226 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11227 if(NULL == wdiKeepAliveInfo)
11228 {
11229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11230 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11231 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11232 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11233 return VOS_STATUS_E_NOMEM;
11234 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11235
11236 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11237 if(NULL == pWdaParams)
11238 {
11239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11240 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11241 VOS_ASSERT(0);
11242 vos_mem_free(wdiKeepAliveInfo);
11243 vos_mem_free(pKeepAliveParams);
11244 return VOS_STATUS_E_NOMEM;
11245 }
11246
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11247 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
11248 pKeepAliveParams->packetType;
11249 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
11250 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11251
11252 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
11253 pKeepAliveParams->bssId,
11254 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11255
11256 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
11257 {
11258 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
11259 pKeepAliveParams->hostIpv4Addr,
11260 SIR_IPV4_ADDR_LEN);
11261 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
11262 pKeepAliveParams->destIpv4Addr,
11263 SIR_IPV4_ADDR_LEN);
11264 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
11265 pKeepAliveParams->destMacAddr,
11266 SIR_MAC_ADDR_LEN);
11267 }
11268 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
11269 {
11270 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
11271 SIR_IPV4_ADDR_LEN,
11272 0);
11273 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
11274 SIR_IPV4_ADDR_LEN,
11275 0);
11276 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
11277 SIR_MAC_ADDR_LEN,
11278 0);
11279 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11280 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
11281 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11282
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11283 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11284 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11285 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11286 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
11287 pWdaParams->pWdaContext = pWDA;
11288
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11289 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
11290 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
11291 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
11292 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
11293 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
11294 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
11295 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
11296 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
11297 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
11298 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
11299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11300 "WDA DMAC : %d:%d:%d:%d:%d:%d",
11301 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
11302 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
11303 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
11304 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
11305 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
11306 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
11307 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11308 "TimePeriod %d PacketType %d",
11309 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
11310 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11311 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11312 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11313
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11314 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11315 {
11316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11317 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11318 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11319 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11320 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]11321 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11322 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11323 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11324
11325}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11326/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11327 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11328 *
11329 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11330void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11331 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
11332 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11333{
11334 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11336 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11337 if(NULL == pWdaParams)
11338 {
11339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11340 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11341 VOS_ASSERT(0) ;
11342 return ;
11343 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11344 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11345 vos_mem_free(pWdaParams->wdaMsgParam);
11346 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11347 return ;
11348}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11349/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11350 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
11351 * Free memory.
11352 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
11353 */
11354void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
11355{
11356 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11357
11358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11359 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11360
11361 if(NULL == pWdaParams)
11362 {
11363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11364 "%s: pWdaParams received NULL", __func__);
11365 VOS_ASSERT(0);
11366 return;
11367 }
11368
11369 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11370 {
11371 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11372 vos_mem_free(pWdaParams->wdaMsgParam);
11373 vos_mem_free(pWdaParams);
11374 }
11375
11376 return;
11377}
11378
11379/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11380 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
11381 * Request to WDI to add WOWL Bcast pattern
11382 */
11383VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
11384 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
11385{
11386 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11387 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11388 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
11389 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
11390 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
11391 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11393 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11394 if(NULL == wdiWowlAddBcPtrnInfo)
11395 {
11396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11397 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11398 VOS_ASSERT(0);
11399 return VOS_STATUS_E_NOMEM;
11400 }
11401 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11402 if(NULL == pWdaParams)
11403 {
11404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11405 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11406 VOS_ASSERT(0);
11407 vos_mem_free(wdiWowlAddBcPtrnInfo);
11408 return VOS_STATUS_E_NOMEM;
11409 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11410 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
11411 pWowlAddBcPtrnParams->ucPatternId;
11412 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
11413 pWowlAddBcPtrnParams->ucPatternByteOffset;
11414 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
11415 pWowlAddBcPtrnParams->ucPatternMaskSize;
11416 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
11417 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11418 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
11419 {
11420 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
11421 pWowlAddBcPtrnParams->ucPattern,
11422 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
11423 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
11424 pWowlAddBcPtrnParams->ucPatternMask,
11425 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
11426 }
11427 else
11428 {
11429 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
11430 pWowlAddBcPtrnParams->ucPattern,
11431 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11432 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
11433 pWowlAddBcPtrnParams->ucPatternMask,
11434 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11435
11436 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
11437 pWowlAddBcPtrnParams->ucPatternExt,
11438 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11439 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
11440 pWowlAddBcPtrnParams->ucPatternMaskExt,
11441 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11442 }
11443
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11444 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
11445 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
11446
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11447 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
11448 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11449 /* Store param pointer as passed in by caller */
11450 /* store Params pass it to WDI */
11451 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
11452 pWdaParams->pWdaContext = pWDA;
11453 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11454 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11455 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11456 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11457 {
11458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11459 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11460 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11461 vos_mem_free(pWdaParams->wdaMsgParam) ;
11462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11463 vos_mem_free(pWdaParams) ;
11464 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11465 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11466
11467}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11468/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11469 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11470 *
11471 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11472void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11473 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
11474 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11475{
11476 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11478 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11479 if(NULL == pWdaParams)
11480 {
11481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11482 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11483 VOS_ASSERT(0) ;
11484 return ;
11485 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11486 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11487 vos_mem_free(pWdaParams->wdaMsgParam);
11488 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11489 return ;
11490}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11491/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11492 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
11493 * Free memory.
11494 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
11495 */
11496void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
11497{
11498 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11499
11500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11501 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11502
11503 if(NULL == pWdaParams)
11504 {
11505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11506 "%s: pWdaParams received NULL", __func__);
11507 VOS_ASSERT(0);
11508 return;
11509 }
11510
11511 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11512 {
11513 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11514 vos_mem_free(pWdaParams->wdaMsgParam);
11515 vos_mem_free(pWdaParams);
11516 }
11517
11518 return;
11519}
11520/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11521 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
11522 * Request to WDI to delete WOWL Bcast pattern
11523 */
11524VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
11525 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
11526{
11527 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11528 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11529 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
11530 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
11531 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
11532 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11534 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11535 if(NULL == wdiWowlDelBcPtrnInfo)
11536 {
11537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11538 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11539 VOS_ASSERT(0);
11540 return VOS_STATUS_E_NOMEM;
11541 }
11542 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11543 if(NULL == pWdaParams)
11544 {
11545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11546 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11547 VOS_ASSERT(0);
11548 vos_mem_free(wdiWowlDelBcPtrnInfo);
11549 return VOS_STATUS_E_NOMEM;
11550 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11551 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
11552 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11553
11554 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
11555 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
11556
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11557 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
11558 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11559 /* Store param pointer as passed in by caller */
11560 /* store Params pass it to WDI */
11561 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
11562 pWdaParams->pWdaContext = pWDA;
11563 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11564 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11565 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11566 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11567 {
11568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11569 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11570 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11571 vos_mem_free(pWdaParams->wdaMsgParam) ;
11572 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11573 vos_mem_free(pWdaParams) ;
11574 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11575 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11576
11577}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11578/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11579 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11580 *
11581 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11582void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11583{
11584 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11585 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11586 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11588 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11589 if(NULL == pWdaParams)
11590 {
11591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11592 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11593 VOS_ASSERT(0) ;
11594 return ;
11595 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11596 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11597 if (NULL == pWDA)
11598 {
11599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11600 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]11601
11602 if(pWdaParams->wdaWdiApiMsgParam)
11603 {
11604 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11605 }
11606 vos_mem_free(pWdaParams);
11607
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11608 VOS_ASSERT(0);
11609 return ;
11610 }
11611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11612 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
11613
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11614 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
11615
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11616 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11617 vos_mem_free(pWdaParams) ;
11618
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11619 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]11620 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11621 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11622 return ;
11623}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11624/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11625 * FUNCTION: WDA_WowlEnterReqCallback
11626 * Free memory and send WOWL Enter RSP back to PE.
11627 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
11628 */
11629void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
11630{
11631 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11632 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11633 tSirHalWowlEnterParams *pWowlEnterParams;
11634
11635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11636 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11637
11638 if(NULL == pWdaParams)
11639 {
11640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11641 "%s: pWdaParams received NULL", __func__);
11642 VOS_ASSERT(0);
11643 return;
11644 }
11645
11646 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11647 if (NULL == pWDA)
11648 {
11649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11650 "%s:pWDA is NULL", __func__);
11651 VOS_ASSERT(0);
11652 return ;
11653 }
11654
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11655 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
11656 pWowlEnterParams->status = wdiStatus;
11657
11658 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11659 {
11660 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11661 vos_mem_free(pWdaParams);
11662 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
11663 }
11664
11665 return;
11666}
11667/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11668 * FUNCTION: WDA_ProcessWowlEnterReq
11669 * Request to WDI to enter WOWL
11670 */
11671VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
11672 tSirHalWowlEnterParams *pWowlEnterParams)
11673{
11674 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11675 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11676 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
11677 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
11678 sizeof(WDI_WowlEnterReqParamsType)) ;
11679 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11681 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11682 if(NULL == wdiWowlEnterInfo)
11683 {
11684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11685 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11686 VOS_ASSERT(0);
11687 return VOS_STATUS_E_NOMEM;
11688 }
11689 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11690 if(NULL == pWdaParams)
11691 {
11692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11693 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11694 VOS_ASSERT(0);
11695 vos_mem_free(wdiWowlEnterInfo);
11696 return VOS_STATUS_E_NOMEM;
11697 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]11698
11699 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
11700
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11701 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
11702 pWowlEnterParams->magicPtrn,
11703 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11704 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
11705 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11706 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
11707 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11708 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
11709 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11710 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
11711 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11712 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
11713 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11714 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
11715 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11716 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
11717 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11718 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
11719 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11720#ifdef WLAN_WAKEUP_EVENTS
11721 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
11722 pWowlEnterParams->ucWoWEAPIDRequestEnable;
11723
11724 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
11725 pWowlEnterParams->ucWoWEAPOL4WayEnable;
11726
11727 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
11728 pWowlEnterParams->ucWowNetScanOffloadMatch;
11729
11730 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
11731 pWowlEnterParams->ucWowGTKRekeyError;
11732
11733 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
11734 pWowlEnterParams->ucWoWBSSConnLoss;
11735#endif // WLAN_WAKEUP_EVENTS
11736
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11737 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
11738 pWowlEnterParams->bssIdx;
11739
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11740 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
11741 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11742 /* Store param pointer as passed in by caller */
11743 /* store Params pass it to WDI */
11744 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
11745 pWdaParams->pWdaContext = pWDA;
11746 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11747 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11748 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11749 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11750 {
11751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11752 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11753 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11754 vos_mem_free(pWdaParams->wdaMsgParam) ;
11755 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11756 vos_mem_free(pWdaParams) ;
11757 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11758 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11759
11760}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11761/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11762 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11763 *
11764 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11765void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11766{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11767 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11768 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11769 tSirHalWowlExitParams *pWowlExitParams;
11770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11771 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11772 if(NULL == pWdaParams)
11773 {
11774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11775 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11776 VOS_ASSERT(0) ;
11777 return ;
11778 }
11779 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11780 if (NULL == pWDA)
11781 {
11782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11783 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]11784
11785 if(pWdaParams->wdaWdiApiMsgParam)
11786 {
11787 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11788 }
11789 vos_mem_free(pWdaParams);
11790
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11791 VOS_ASSERT(0);
11792 return ;
11793 }
11794
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11795 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
11796
11797 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]11798 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11799
11800 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11801 vos_mem_free(pWdaParams) ;
11802
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11804 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11805 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11806 return ;
11807}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11808/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11809 * FUNCTION: WDA_WowlExitReqCallback
11810 * Free memory and send WOWL Exit RSP back to PE.
11811 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
11812 */
11813void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
11814{
11815 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11816 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11817 tSirHalWowlExitParams *pWowlExitParams;
11818
11819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11820 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11821
11822 if(NULL == pWdaParams)
11823 {
11824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11825 "%s: pWdaParams received NULL", __func__);
11826 VOS_ASSERT(0);
11827 return;
11828 }
11829
11830 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11831 if (NULL == pWDA)
11832 {
11833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11834 "%s:pWDA is NULL", __func__);
11835 VOS_ASSERT(0);
11836 return ;
11837 }
11838
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11839 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
11840 pWowlExitParams->status = wdiStatus;
11841
11842 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11843 {
11844 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11845 vos_mem_free(pWdaParams);
11846 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
11847 }
11848
11849 return;
11850}
11851/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11852 * FUNCTION: WDA_ProcessWowlExitReq
11853 * Request to WDI to add WOWL Bcast pattern
11854 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11855VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
11856 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11857{
11858 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11859 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11860 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
11861 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
11862 sizeof(WDI_WowlExitReqParamsType)) ;
11863 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11865 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11866 if(NULL == wdiWowlExitInfo)
11867 {
11868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11869 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11870 VOS_ASSERT(0);
11871 return VOS_STATUS_E_NOMEM;
11872 }
11873 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11874 if(NULL == pWdaParams)
11875 {
11876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11877 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11878 VOS_ASSERT(0);
11879 vos_mem_free(wdiWowlExitInfo);
11880 return VOS_STATUS_E_NOMEM;
11881 }
11882
11883 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
11884 pWowlExitParams->bssIdx;
11885
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11886 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
11887 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11888
11889 /* Store param pointer as passed in by caller */
11890 /* store Params pass it to WDI */
11891 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
11892 pWdaParams->pWdaContext = pWDA;
11893 pWdaParams->wdaMsgParam = pWowlExitParams;
11894
11895 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11896 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11897
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11898 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11899 {
11900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11901 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11902 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11903 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11904 vos_mem_free(pWdaParams->wdaMsgParam);
11905 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11906 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11907 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11908}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11909/*
11910 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
11911 * Request to WDI to determine whether a given station is capable of
11912 * using HW-based frame translation
11913 */
11914v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
11915 tANI_U8 staIdx)
11916{
11917 return WDI_IsHwFrameTxTranslationCapable(staIdx);
11918}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]11919
11920/*
11921 * FUNCTION: WDA_IsSelfSTA
11922 * Request to WDI to determine whether a given STAID is self station
11923 * index.
11924 */
11925v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
11926{
11927
11928 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
11929
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]11930 if (NULL != pWDA)
11931 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
11932 else
11933 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]11934}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11935/*
11936 * FUNCTION: WDA_NvDownloadReqCallback
11937 * send NV Download RSP back to PE
11938 */
11939void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
11940 void* pUserData)
11941{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11942
11943 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11944 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11945
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11947 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11948
11949 if(NULL == pWdaParams)
11950 {
11951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11952 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11953 VOS_ASSERT(0) ;
11954 return ;
11955 }
11956
11957 pWDA = pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11958 if (NULL == pWDA)
11959 {
11960 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11961 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]11962
11963 if(pWdaParams->wdaWdiApiMsgParam)
11964 {
11965 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11966 }
11967 vos_mem_free(pWdaParams);
11968
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11969 VOS_ASSERT(0);
11970 return ;
11971 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11972
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11973 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11975 vos_mem_free(pWdaParams);
11976
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11977 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11978 return ;
11979}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11980/*
11981 * FUNCTION: WDA_ProcessNvDownloadReq
11982 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
11983 */
11984VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
11985{
11986 /* Initialize the local Variables*/
11987 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
11988 v_VOID_t *pNvBuffer=NULL;
11989 v_SIZE_t bufferSize = 0;
11990 WDI_Status status = WDI_STATUS_E_FAILURE;
11991 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11992 tWDA_ReqParams *pWdaParams ;
11993
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11995 "------> %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11996 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11997 {
11998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11999 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12000 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12001 return VOS_STATUS_E_FAILURE;
12002 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12003
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12004 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]12005 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
12006
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12007 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
12008 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12009 if(NULL == wdiNvDownloadReqParam)
12010 {
12011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12012 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12013 VOS_ASSERT(0);
12014 return VOS_STATUS_E_NOMEM;
12015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12016 /* Copy Params to wdiNvDownloadReqParam*/
12017 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
12018 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12019
12020 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12021 if(NULL == pWdaParams)
12022 {
12023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12024 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12025 VOS_ASSERT(0);
12026 vos_mem_free(wdiNvDownloadReqParam);
12027 return VOS_STATUS_E_NOMEM;
12028 }
12029
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12030 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12031 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
12032 pWdaParams->wdaMsgParam = NULL;
12033 pWdaParams->pWdaContext = pWDA;
12034
12035
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12036 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12037
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12038 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12039 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
12040
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12041 if(IS_WDI_STATUS_FAILURE(status))
12042 {
12043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12044 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12045 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12046 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12047 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12048 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12049}
12050/*
12051 * FUNCTION: WDA_FlushAcReqCallback
12052 * send Flush AC RSP back to TL
12053 */
12054void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
12055{
12056 vos_msg_t wdaMsg = {0} ;
12057 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12058 tFlushACReq *pFlushACReqParams;
12059 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12061 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12062 if(NULL == pWdaParams)
12063 {
12064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12065 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12066 VOS_ASSERT(0) ;
12067 return ;
12068 }
12069
12070 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
12071 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
12072 if(NULL == pFlushACRspParams)
12073 {
12074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12075 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12076 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12077 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12078 return ;
12079 }
12080 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
12081 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
12082 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
12083 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
12084 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]12085 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12086 vos_mem_free(pWdaParams->wdaMsgParam) ;
12087 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12088 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12089 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
12090 wdaMsg.bodyptr = (void *)pFlushACRspParams;
12091 // POST message to TL
12092 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
12093
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12094 return ;
12095}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12096/*
12097 * FUNCTION: WDA_ProcessFlushAcReq
12098 * Request to WDI to Update the DELBA REQ params.
12099 */
12100VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
12101 tFlushACReq *pFlushAcReqParams)
12102{
12103 WDI_Status status = WDI_STATUS_SUCCESS ;
12104 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
12105 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
12106 sizeof(WDI_FlushAcReqParamsType)) ;
12107 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12108 if(NULL == wdiFlushAcReqParam)
12109 {
12110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12111 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12112 VOS_ASSERT(0);
12113 return VOS_STATUS_E_NOMEM;
12114 }
12115 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12116 if(NULL == pWdaParams)
12117 {
12118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12119 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12120 VOS_ASSERT(0);
12121 vos_mem_free(wdiFlushAcReqParam);
12122 return VOS_STATUS_E_NOMEM;
12123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12125 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12126 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
12127 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
12128 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
12129 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12130 /* Store Flush AC pointer, as this will be used for response */
12131 /* store Params pass it to WDI */
12132 pWdaParams->pWdaContext = pWDA;
12133 pWdaParams->wdaMsgParam = pFlushAcReqParams;
12134 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12135 status = WDI_FlushAcReq(wdiFlushAcReqParam,
12136 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12137 if(IS_WDI_STATUS_FAILURE(status))
12138 {
12139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12140 "Failure in Flush AC REQ Params WDI API, free all the memory " );
12141 vos_mem_free(pWdaParams->wdaMsgParam) ;
12142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12143 vos_mem_free(pWdaParams) ;
12144 //TODO: respond to TL with failure
12145 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12146 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12148/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12149 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12150 *
12151 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12152void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12153{
12154 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12155 tWDA_CbContext *pWDA = NULL;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12156 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12157
12158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12159 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12160 if(NULL == pWdaParams)
12161 {
12162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12163 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12164 VOS_ASSERT(0) ;
12165 return ;
12166 }
12167 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12168 if (NULL == pWDA)
12169 {
12170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12171 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]12172 vos_mem_free(pWdaParams->wdaMsgParam) ;
12173 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12174 vos_mem_free(pWdaParams) ;
12175
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12176 VOS_ASSERT(0);
12177 return ;
12178 }
12179
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12180 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
12181 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
12182 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12183 {
12184 pWDA->wdaAmpSessionOn = VOS_FALSE;
12185 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12186 vos_mem_free(pWdaParams->wdaMsgParam) ;
12187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12188 vos_mem_free(pWdaParams) ;
12189 /*
12190 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
12191 * param here
12192 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12193 return ;
12194}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12195/*
12196 * FUNCTION: WDA_BtAmpEventReqCallback
12197 * Free memory.
12198 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
12199 */
12200void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
12201{
12202 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12203 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12204 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12205
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12207 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12208
12209 if(NULL == pWdaParams)
12210 {
12211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12212 "%s: pWdaParams received NULL", __func__);
12213 VOS_ASSERT(0);
12214 return;
12215 }
12216
12217 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12218 if (NULL == pWDA)
12219 {
12220 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12221 "%s:pWDA is NULL", __func__);
12222 VOS_ASSERT(0);
12223 return ;
12224 }
12225
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12226 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
12227
12228 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
12229 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12230 {
12231 pWDA->wdaAmpSessionOn = VOS_FALSE;
12232 }
12233
12234 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12235 {
12236 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12237 vos_mem_free(pWdaParams->wdaMsgParam);
12238 vos_mem_free(pWdaParams);
12239 }
12240
12241 return;
12242}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12243/*
12244 * FUNCTION: WDA_ProcessBtAmpEventReq
12245 * Request to WDI to Update with BT AMP events.
12246 */
12247VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
12248 tSmeBtAmpEvent *pBtAmpEventParams)
12249{
12250 WDI_Status status = WDI_STATUS_SUCCESS ;
12251 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
12252 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
12253 sizeof(WDI_BtAmpEventParamsType)) ;
12254 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12256 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12257 if(NULL == wdiBtAmpEventParam)
12258 {
12259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12260 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12261 VOS_ASSERT(0);
12262 return VOS_STATUS_E_NOMEM;
12263 }
12264 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12265 if(NULL == pWdaParams)
12266 {
12267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12268 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12269 VOS_ASSERT(0);
12270 vos_mem_free(wdiBtAmpEventParam);
12271 return VOS_STATUS_E_NOMEM;
12272 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12273 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
12274 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12275 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
12276 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12277 /* Store BT AMP event pointer, as this will be used for response */
12278 /* store Params pass it to WDI */
12279 pWdaParams->pWdaContext = pWDA;
12280 pWdaParams->wdaMsgParam = pBtAmpEventParams;
12281 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12282 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12283 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12284 if(IS_WDI_STATUS_FAILURE(status))
12285 {
12286 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12287 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
12288 vos_mem_free(pWdaParams->wdaMsgParam) ;
12289 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12290 vos_mem_free(pWdaParams) ;
12291 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12292 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12293 {
12294 pWDA->wdaAmpSessionOn = VOS_TRUE;
12295 }
12296 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12297}
12298
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12299/*
12300 * FUNCTION: WDA_FTMCommandReqCallback
12301 * Handle FTM CMD response came from HAL
12302 * Route responce to HDD FTM
12303 */
12304void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
12305 void *usrData)
12306{
12307 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12308 if((NULL == pWDA) || (NULL == ftmCmdRspData))
12309 {
12310 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12311 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12312 return;
12313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12314 /* Release Current FTM Command Request */
12315 vos_mem_free(pWDA->wdaFTMCmdReq);
12316 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12317 /* Post FTM Responce to HDD FTM */
12318 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12319 return;
12320}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12321/*
12322 * FUNCTION: WDA_ProcessFTMCommand
12323 * Send FTM command to WDI
12324 */
12325VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
12326 tPttMsgbuffer *pPTTFtmCmd)
12327{
12328 WDI_Status status = WDI_STATUS_SUCCESS;
12329 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12330 ftmCMDReq = (WDI_FTMCommandReqType *)
12331 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
12332 if(NULL == ftmCMDReq)
12333 {
12334 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12335 "WDA FTM Command buffer alloc fail");
12336 return VOS_STATUS_E_NOMEM;
12337 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12338 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
12339 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12340 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12341 /* Send command to WDI */
12342 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12343 return status;
12344}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12345#ifdef FEATURE_OEM_DATA_SUPPORT
12346/*
12347 * FUNCTION: WDA_StartOemDataReqCallback
12348 *
12349 */
12350void WDA_StartOemDataReqCallback(
12351 WDI_oemDataRspParamsType *wdiOemDataRspParams,
12352 void* pUserData)
12353{
12354 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12355 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12356 tWDA_CbContext *pWDA = NULL;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12357 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12358
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12360 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12361
12362 if(NULL == pWdaParams)
12363 {
12364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12365 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12366 VOS_ASSERT(0) ;
12367 return ;
12368 }
12369 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
12370
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12371 if (NULL == pWDA)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12372 {
12373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12374 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12375 VOS_ASSERT(0);
12376 return ;
12377 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12378
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12379 /*
12380 * Allocate memory for response params sent to PE
12381 */
12382 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
12383
12384 // Check if memory is allocated for OemdataMeasRsp Params.
12385 if(NULL == pOemDataRspParams)
12386 {
12387 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12388 "OEM DATA WDA callback alloc fail");
12389 VOS_ASSERT(0) ;
12390 return;
12391 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12392
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12393 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12394 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12395 vos_mem_free(pWdaParams->wdaMsgParam);
12396 vos_mem_free(pWdaParams) ;
12397
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12398 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12399 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12400 * Also, here success always means that we have atleast one BSSID.
12401 */
12402 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
12403
12404 //enable Tx
12405 status = WDA_ResumeDataTx(pWDA);
12406 if(status != VOS_STATUS_SUCCESS)
12407 {
12408 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
12409 }
12410 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
12411 return ;
12412}
12413/*
12414 * FUNCTION: WDA_ProcessStartOemDataReq
12415 * Send Start Oem Data Req to WDI
12416 */
12417VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
12418 tStartOemDataReq *pOemDataReqParams)
12419{
12420 WDI_Status status = WDI_STATUS_SUCCESS;
12421 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12422 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12423
12424 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
12425
12426 if(NULL == wdiOemDataReqParams)
12427 {
12428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12429 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12430 VOS_ASSERT(0);
12431 return VOS_STATUS_E_NOMEM;
12432 }
12433
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12434 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
12435 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
12436 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
12437 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12438
12439 wdiOemDataReqParams->wdiReqStatusCB = NULL;
12440
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12441 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12442 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12443 {
12444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12445 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12446 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12447 vos_mem_free(pOemDataReqParams);
12448 VOS_ASSERT(0);
12449 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12450 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12451
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]12452 pWdaParams->pWdaContext = (void*)pWDA;
12453 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
12454 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12455
12456 status = WDI_StartOemDataReq(wdiOemDataReqParams,
12457 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12458
12459 if(IS_WDI_STATUS_FAILURE(status))
12460 {
12461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12462 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12463 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12464 vos_mem_free(pWdaParams->wdaMsgParam);
12465 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12466 }
12467 return CONVERT_WDI2VOS_STATUS(status) ;
12468}
12469#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12470/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12471 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12472 *
12473 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12474void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12475{
12476 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12478 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12479 if(NULL == pWdaParams)
12480 {
12481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12482 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12483 VOS_ASSERT(0) ;
12484 return ;
12485 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12486
12487 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12488 vos_mem_free(pWdaParams->wdaMsgParam);
12489 vos_mem_free(pWdaParams);
12490
12491 return ;
12492}
12493/*
12494 * FUNCTION: WDA_SetTxPerTrackingReqCallback
12495 * Free memory.
12496 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
12497 */
12498void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
12499{
12500 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12501
12502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12503 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12504
12505 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12506 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12508 "%s: pWdaParams received NULL", __func__);
12509 VOS_ASSERT(0);
12510 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12511 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12512
12513 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12514 {
12515 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12516 vos_mem_free(pWdaParams->wdaMsgParam);
12517 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12518 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12519
12520 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12521}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12522#ifdef WLAN_FEATURE_GTK_OFFLOAD
12523/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12524 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12525 *
12526 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12527void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12528 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12529{
12530 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12531
12532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12533 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]12534 if(NULL == pWdaParams)
12535 {
12536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12537 "%s: pWdaParams received NULL", __func__);
12538 VOS_ASSERT(0);
12539 return;
12540 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12541
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12542 vos_mem_free(pWdaParams->wdaMsgParam) ;
12543 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12544 vos_mem_free(pWdaParams) ;
12545
12546 //print a msg, nothing else to do
12547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12548 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12549
12550 return ;
12551}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12552/*
12553 * FUNCTION: WDA_GTKOffloadReqCallback
12554 * Free memory.
12555 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
12556 */
12557void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
12558{
12559 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12560
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12562 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12563
12564 if(NULL == pWdaParams)
12565 {
12566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12567 "%s: pWdaParams received NULL", __func__);
12568 VOS_ASSERT(0);
12569 return;
12570 }
12571
12572 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12573 {
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]12574 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
12575 sizeof(WDI_GtkOffloadReqMsg));
12576 vos_mem_zero(pWdaParams->wdaMsgParam,
12577 sizeof(tSirGtkOffloadParams));
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12578 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12579 vos_mem_free(pWdaParams->wdaMsgParam);
12580 vos_mem_free(pWdaParams);
12581 }
12582
12583 return;
12584}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12585/*
12586 * FUNCTION: WDA_ProcessGTKOffloadReq
12587 * Request to WDI to set the filter to minimize unnecessary host wakeup due
12588 * to broadcast traffic (sta mode).
12589 */
12590VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
12591 tpSirGtkOffloadParams pGtkOffloadParams)
12592{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12593 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12594 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
12595 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
12596 sizeof(WDI_GtkOffloadReqMsg)) ;
12597 tWDA_ReqParams *pWdaParams ;
12598
12599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12600 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12601
12602 if(NULL == wdiGtkOffloadReqMsg)
12603 {
12604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12605 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12606 VOS_ASSERT(0);
12607 return VOS_STATUS_E_NOMEM;
12608 }
12609
12610 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12611 if(NULL == pWdaParams)
12612 {
12613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12614 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12615 VOS_ASSERT(0);
12616 vos_mem_free(wdiGtkOffloadReqMsg);
12617 return VOS_STATUS_E_NOMEM;
12618 }
12619
12620 //
12621 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
12622 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12623
12624 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12625 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12626
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12627 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
12628 // Copy KCK
12629 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
12630 // Copy KEK
12631 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
12632 // Copy KeyReplayCounter
12633 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
12634 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
12635
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12636 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
12637 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12638
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12639
12640 /* Store Params pass it to WDI */
12641 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
12642 pWdaParams->pWdaContext = pWDA;
12643 /* Store param pointer as passed in by caller */
12644 pWdaParams->wdaMsgParam = pGtkOffloadParams;
12645
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12646 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12647
12648 if(IS_WDI_STATUS_FAILURE(status))
12649 {
12650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12651 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]12652 vos_mem_zero(wdiGtkOffloadReqMsg, sizeof(WDI_GtkOffloadReqMsg));
12653 vos_mem_zero(pGtkOffloadParams, sizeof(tSirGtkOffloadParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12654 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12655 vos_mem_free(pWdaParams->wdaMsgParam);
12656 vos_mem_free(pWdaParams);
12657 }
12658
12659 return CONVERT_WDI2VOS_STATUS(status) ;
12660}
12661
12662/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12663 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12664 *
12665 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12666void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12667 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12668{
12669 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12670 tWDA_CbContext *pWDA;
12671 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]12672 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12673 vos_msg_t vosMsg;
12674
12675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12676 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]12677
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]12678 if(NULL == pWdaParams)
12679 {
12680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12681 "%s: pWdaParams received NULL", __func__);
12682 VOS_ASSERT(0);
12683 return;
12684 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12685
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]12686 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
12687 if(NULL == pGtkOffloadGetInfoRsp)
12688 {
12689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12690 "%s: vos_mem_malloc failed ", __func__);
12691 VOS_ASSERT(0);
12692 return;
12693 }
12694
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12695 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
12696 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
12697
12698 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
12699 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
12700
12701 /* Message Header */
12702 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]12703 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12704
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12705 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
12706 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
12707 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
12708 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
12709 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12710
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12711 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
12712 pwdiGtkOffloadGetInfoRsparams->bssId,
12713 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12714 /* VOS message wrapper */
12715 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
12716 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
12717 vosMsg.bodyval = 0;
12718
12719 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
12720 {
12721 /* free the mem and return */
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]12722 vos_mem_zero(pGtkOffloadGetInfoRsp,
12723 sizeof(tSirGtkOffloadGetInfoRspParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12724 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
12725 }
12726
12727 vos_mem_free(pWdaParams->wdaMsgParam) ;
12728 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12729 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12730
12731 return;
12732}
12733/*
12734 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
12735 * Free memory and send RSP back to SME.
12736 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
12737 */
12738void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
12739{
12740 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12741 vos_msg_t vosMsg;
12742
12743 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12744 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12745
12746 if(NULL == pWdaParams)
12747 {
12748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12749 "%s: pWdaParams received NULL", __func__);
12750 VOS_ASSERT(0);
12751 return;
12752 }
12753
12754 /* VOS message wrapper */
12755 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
12756 vosMsg.bodyptr = NULL;
12757 vosMsg.bodyval = 0;
12758
12759 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12760 {
12761 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12762 vos_mem_free(pWdaParams->wdaMsgParam);
12763 vos_mem_free(pWdaParams);
12764 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
12765 }
12766
12767 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12768}
12769#endif
12770
12771/*
12772 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
12773 * Request to WDI to set Tx Per Tracking configurations
12774 */
12775VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
12776{
12777 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12778 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12779 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
12780 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
12781 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
12782 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12784 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12785 if(NULL == pwdiSetTxPerTrackingReqParams)
12786 {
12787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12788 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12789 vos_mem_free(pTxPerTrackingParams);
12790 VOS_ASSERT(0);
12791 return VOS_STATUS_E_NOMEM;
12792 }
12793 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12794 if(NULL == pWdaParams)
12795 {
12796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12797 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12798 vos_mem_free(pwdiSetTxPerTrackingReqParams);
12799 vos_mem_free(pTxPerTrackingParams);
12800 VOS_ASSERT(0);
12801 return VOS_STATUS_E_NOMEM;
12802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12803 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
12804 pTxPerTrackingParams->ucTxPerTrackingEnable;
12805 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
12806 pTxPerTrackingParams->ucTxPerTrackingPeriod;
12807 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
12808 pTxPerTrackingParams->ucTxPerTrackingRatio;
12809 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
12810 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12811 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
12812 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12813 /* Store param pointer as passed in by caller */
12814 /* store Params pass it to WDI
12815 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
12816 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
12817 pWdaParams->pWdaContext = pWDA;
12818 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12819 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12820 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12821 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12822 {
12823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12824 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12825 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12826 vos_mem_free(pWdaParams->wdaMsgParam) ;
12827 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12828 vos_mem_free(pWdaParams) ;
12829 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12830 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12831
12832}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12833/*
12834 * FUNCTION: WDA_HALDumpCmdCallback
12835 * Send the VOS complete .
12836 */
12837void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
12838 void* pUserData)
12839{
12840 tANI_U8 *buffer = NULL;
12841 tWDA_CbContext *pWDA = NULL;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12842 tWDA_HalDumpReqParams *pWdaParams = (tWDA_HalDumpReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12843 if(NULL == pWdaParams)
12844 {
12845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12846 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12847 VOS_ASSERT(0) ;
12848 return ;
12849 }
12850
12851 pWDA = pWdaParams->pWdaContext;
12852 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12853 if(wdiRspParams->usBufferLen > 0)
12854 {
12855 /*Copy the Resp data to UMAC supplied buffer*/
12856 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
12857 }
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12858
12859 if (!pWdaParams->wdaHALDumpAsync)
12860 {/* Indicate VOSS about the start complete */
12861 vos_WDAComplete_cback(pWDA->pVosContext);
12862 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12863 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12864 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12865 return ;
12866}
12867
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12868/*
12869 * FUNCTION: WDA_ProcessHALDumpCmdReq
12870 * Send Dump command to WDI
12871 */
12872VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
12873 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12874 tANI_U32 arg4, tANI_U8 *pBuffer, wpt_boolean async)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12875{
12876 WDI_Status status = WDI_STATUS_SUCCESS;
12877 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
12878 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12879 tWDA_HalDumpReqParams *pWdaParams ;
12880
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12881 pVosContextType pVosContext = NULL;
12882 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12883 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
12884 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]12885 if(pVosContext)
12886 {
12887 if (pVosContext->isLogpInProgress)
12888 {
12889 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
12890 "%s:LOGP in Progress. Ignore!!!", __func__);
12891 return VOS_STATUS_E_BUSY;
12892 }
12893 }
12894 else
12895 {
12896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12897 "%s: VOS Context Null", __func__);
12898 return VOS_STATUS_E_RESOURCES;
12899 }
12900
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12901 if (NULL == pVosContext->pWDAContext)
12902 {
12903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12904 "%s: WDA Context Null", __func__);
12905 return VOS_STATUS_E_RESOURCES;
12906 }
12907 pWdaParams = (tWDA_HalDumpReqParams *)vos_mem_malloc(sizeof(tWDA_HalDumpReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12908 if(NULL == pWdaParams)
12909 {
12910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12911 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12912 return VOS_STATUS_E_NOMEM;
12913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12914 /* Allocate memory WDI request structure*/
12915 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
12916 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
12917 if(NULL == wdiHALDumpCmdReqParam)
12918 {
12919 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12920 "WDA HAL DUMP Command buffer alloc fail");
12921 vos_mem_free(pWdaParams);
12922 return WDI_STATUS_E_FAILURE;
12923 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12924 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12925 /* Extract the arguments */
12926 wdiHalDumpCmdInfo->command = cmd;
12927 wdiHalDumpCmdInfo->argument1 = arg1;
12928 wdiHalDumpCmdInfo->argument2 = arg2;
12929 wdiHalDumpCmdInfo->argument3 = arg3;
12930 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12931 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12932 pWdaParams->pWdaContext = pVosContext->pWDAContext;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12933 pWdaParams->wdaHALDumpAsync = async;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12934
12935 /* Response message will be passed through the buffer */
12936 pWdaParams->wdaMsgParam = (void *)pBuffer;
12937
12938 /* store Params pass it to WDI */
12939 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12940 /* Send command to WDI */
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12941 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback,
12942 pWdaParams);
12943 /* For Sync event only wait for rsp until completion of wdaCompleteEvent*/
12944 if (!async)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12945 {
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12946 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent),
12947 WDA_DUMPCMD_WAIT_TIMEOUT );
12948 if ( vStatus != VOS_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12949 {
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]12950 if ( vStatus == VOS_STATUS_E_TIMEOUT )
12951 {
12952 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
12953 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
12954 }
12955 else
12956 {
12957 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
12958 "%s: WDA_HALDUMP reporting other error",__func__);
12959 }
12960 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12961 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12962 }
12963 return status;
12964}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12965#ifdef WLAN_FEATURE_GTK_OFFLOAD
12966/*
12967 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
12968 * Request to WDI to get GTK Offload Information
12969 */
12970VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
12971 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
12972{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12973 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12974 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
12975 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
12976 tWDA_ReqParams *pWdaParams ;
12977
12978 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
12979 {
12980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12981 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12982 VOS_ASSERT(0);
12983 return VOS_STATUS_E_NOMEM;
12984 }
12985
12986 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12987 if(NULL == pWdaParams)
12988 {
12989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12990 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12991 VOS_ASSERT(0);
12992 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
12993 return VOS_STATUS_E_NOMEM;
12994 }
12995
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12996 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
12997 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12998
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12999 /* Store Params pass it to WDI */
13000 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
13001 pWdaParams->pWdaContext = pWDA;
13002 /* Store param pointer as passed in by caller */
13003 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
13004
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13005 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]13006 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13007
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13008 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13009
13010 if(IS_WDI_STATUS_FAILURE(status))
13011 {
13012 /* failure returned by WDI API */
13013 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13014 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
13015 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13016 vos_mem_free(pWdaParams) ;
13017 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
13018 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
13019 }
13020
13021 return CONVERT_WDI2VOS_STATUS(status) ;
13022}
13023#endif // WLAN_FEATURE_GTK_OFFLOAD
13024
13025/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13026 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
13027 *
13028 */
13029VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
13030 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
13031{
13032 WDI_Status wdiStatus;
13033 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
13034
13035 addPeriodicTxPtrnParams =
13036 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
13037
13038 if (NULL == addPeriodicTxPtrnParams)
13039 {
13040 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13041 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
13042 __func__);
13043
13044 return VOS_STATUS_E_NOMEM;
13045 }
13046
13047 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
13048 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
13049
13050 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
13051 addPeriodicTxPtrnParams->pUserData = pWDA;
13052
13053 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
13054
13055 if (WDI_STATUS_PENDING == wdiStatus)
13056 {
13057 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13058 "Pending received for %s:%d", __func__, __LINE__ );
13059 }
13060 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13061 {
13062 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13063 "Failure in %s:%d", __func__, __LINE__ );
13064 }
13065
13066 vos_mem_free(addPeriodicTxPtrnParams);
13067
13068 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13069}
13070
13071/*
13072 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
13073 *
13074 */
13075VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
13076 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
13077{
13078 WDI_Status wdiStatus;
13079 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
13080
13081 delPeriodicTxPtrnParams =
13082 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
13083
13084 if (NULL == delPeriodicTxPtrnParams)
13085 {
13086 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13087 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
13088 __func__);
13089
13090 return VOS_STATUS_E_NOMEM;
13091 }
13092
13093 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
13094 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
13095
13096 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
13097 delPeriodicTxPtrnParams->pUserData = pWDA;
13098
13099 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
13100
13101 if (WDI_STATUS_PENDING == wdiStatus)
13102 {
13103 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13104 "Pending received for %s:%d", __func__, __LINE__ );
13105 }
13106 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13107 {
13108 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13109 "Failure in %s:%d", __func__, __LINE__ );
13110 }
13111
13112 vos_mem_free(delPeriodicTxPtrnParams);
13113
13114 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13115}
13116
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13117#ifdef FEATURE_WLAN_BATCH_SCAN
13118/*
13119 * FUNCTION: WDA_ProcessStopBatchScanInd
13120 *
13121 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
13122 *
13123 * PARAM:
13124 * pWDA: pointer to WDA context
13125 * pReq: pointer to stop batch scan request
13126 */
13127VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
13128 tSirStopBatchScanInd *pReq)
13129{
13130 WDI_Status wdiStatus;
13131 WDI_StopBatchScanIndType wdiReq;
13132
13133 wdiReq.param = pReq->param;
13134
13135 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
13136
13137 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13138 {
13139 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13140 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
13141 }
13142
13143 vos_mem_free(pReq);
13144
13145 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13146}
13147/*==========================================================================
13148 FUNCTION WDA_ProcessTriggerBatchScanResultInd
13149
13150 DESCRIPTION
13151 API to pull batch scan result from FW
13152
13153 PARAMETERS
13154 pWDA: Pointer to WDA context
13155 pGetBatchScanReq: Pointer to get batch scan result indication
13156
13157 RETURN VALUE
13158 NONE
13159
13160===========================================================================*/
13161VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
13162 tSirTriggerBatchScanResultInd *pReq)
13163{
13164 WDI_Status wdiStatus;
13165 WDI_TriggerBatchScanResultIndType wdiReq;
13166
13167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13168 "------> %s " ,__func__);
13169
13170 wdiReq.param = pReq->param;
13171
13172 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
13173
13174 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13175 {
13176 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13177 "Trigger batch scan result ind failed %s:%d",
13178 __func__, wdiStatus);
13179 }
13180
13181 vos_mem_free(pReq);
13182
13183 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13184}
13185
13186/*==========================================================================
13187 FUNCTION WDA_SetBatchScanRespCallback
13188
13189 DESCRIPTION
13190 API to process set batch scan response from FW
13191
13192 PARAMETERS
13193 pRsp: Pointer to set batch scan response
13194 pUserData: Pointer to user data
13195
13196 RETURN VALUE
13197 NONE
13198
13199===========================================================================*/
13200void WDA_SetBatchScanRespCallback
13201(
13202 WDI_SetBatchScanRspType *pRsp,
13203 void* pUserData
13204)
13205{
13206 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
13207 tpAniSirGlobal pMac;
13208 void *pCallbackContext;
13209 tWDA_CbContext *pWDA = NULL ;
13210 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13211
13212
13213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13214 "<------ %s " ,__func__);
13215 if (NULL == pWdaParams)
13216 {
13217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13218 "%s: pWdaParams received NULL", __func__);
13219 VOS_ASSERT(0) ;
13220 return ;
13221 }
13222
13223 /*extract WDA context*/
13224 pWDA = pWdaParams->pWdaContext;
13225 if (NULL == pWDA)
13226 {
13227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13228 "%s:pWDA is NULL can't invole HDD callback",
13229 __func__);
13230 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13231 vos_mem_free(pWdaParams->wdaMsgParam);
13232 vos_mem_free(pWdaParams);
13233 VOS_ASSERT(0);
13234 return;
13235 }
13236
13237 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13238 vos_mem_free(pWdaParams->wdaMsgParam);
13239 vos_mem_free(pWdaParams);
13240
13241 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13242 if (NULL == pMac)
13243 {
13244 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13245 "%s:pMac is NULL", __func__);
13246 VOS_ASSERT(0);
13247 return;
13248 }
13249
13250 pHddSetBatchScanRsp =
13251 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
13252 if (NULL == pHddSetBatchScanRsp)
13253 {
13254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13255 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
13256 VOS_ASSERT(0);
13257 return;
13258 }
13259
13260 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
13261
13262 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
13263 /*call hdd callback with set batch scan response data*/
13264 if(pMac->pmc.setBatchScanReqCallback)
13265 {
13266 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
13267 }
13268 else
13269 {
13270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13271 "%s:HDD callback is null", __func__);
13272 VOS_ASSERT(0);
13273 }
13274
13275 vos_mem_free(pHddSetBatchScanRsp);
13276 return ;
13277}
13278
13279/*==========================================================================
13280 FUNCTION WDA_ProcessSetBatchScanReq
13281
13282 DESCRIPTION
13283 API to send set batch scan request to WDI
13284
13285 PARAMETERS
13286 pWDA: Pointer to WDA context
13287 pSetBatchScanReq: Pointer to set batch scan req
13288
13289 RETURN VALUE
13290 NONE
13291
13292===========================================================================*/
13293VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
13294 tSirSetBatchScanReq *pSetBatchScanReq)
13295{
13296 WDI_Status status;
13297 tWDA_ReqParams *pWdaParams ;
13298 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
13299
13300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13301 "------> %s " ,__func__);
13302
13303 pWdiSetBatchScanReq =
13304 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
13305 if (NULL == pWdiSetBatchScanReq)
13306 {
13307 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13308 "%s: VOS MEM Alloc Failure", __func__);
13309 vos_mem_free(pSetBatchScanReq);
13310 VOS_ASSERT(0);
13311 return VOS_STATUS_E_NOMEM;
13312 }
13313
13314 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
13315 if (NULL == pWdaParams)
13316 {
13317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13318 "%s: VOS MEM Alloc Failure", __func__);
13319 VOS_ASSERT(0);
13320 vos_mem_free(pSetBatchScanReq);
13321 vos_mem_free(pWdiSetBatchScanReq);
13322 return VOS_STATUS_E_NOMEM;
13323 }
13324
13325 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
13326 pWdiSetBatchScanReq->numberOfScansToBatch =
13327 pSetBatchScanReq->numberOfScansToBatch;
13328 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
13329 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
13330 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
13331
13332 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
13333 pWdaParams->pWdaContext = pWDA;
13334 pWdaParams->wdaMsgParam = pSetBatchScanReq;
13335
13336 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
13337 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
13338 if (IS_WDI_STATUS_FAILURE(status))
13339 {
13340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13341 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
13342 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13343 vos_mem_free(pWdaParams->wdaMsgParam);
13344 vos_mem_free(pWdaParams);
13345 }
13346 return CONVERT_WDI2VOS_STATUS(status);
13347}
13348
13349#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13350/*
13351 * FUNCTION: WDA_ProcessHT40OBSSScanInd
13352 *
13353 * DESCRIPTION: This function sends start/update OBSS scan
13354 * inidcation message to WDI
13355 *
13356 * PARAM:
13357 * pWDA: pointer to WDA context
13358 * pReq: pointer to start OBSS scan request
13359 */
13360VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
13361 tSirHT40OBSSScanInd *pReq)
13362{
13363 WDI_Status status;
13364 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
13365 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13366
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13368 "------> %s " ,__func__);
13369 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13370 wdiOBSSScanParams.pUserData = pWDA;
13371
13372 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
13373 pWdiOBSSScanInd->cmdType = pReq->cmdType;
13374 pWdiOBSSScanInd->scanType = pReq->scanType;
13375 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
13376 pReq->OBSSScanActiveDwellTime;
13377 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
13378 pReq->OBSSScanPassiveDwellTime;
13379 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
13380 pReq->BSSChannelWidthTriggerScanInterval;
13381 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
13382 pReq->BSSWidthChannelTransitionDelayFactor;
13383 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
13384 pReq->OBSSScanActiveTotalPerChannel;
13385 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
13386 pReq->OBSSScanPassiveTotalPerChannel;
13387 pWdiOBSSScanInd->OBSSScanActivityThreshold =
13388 pReq->OBSSScanActivityThreshold;
13389 pWdiOBSSScanInd->channelCount = pReq->channelCount;
13390 vos_mem_copy(pWdiOBSSScanInd->channels,
13391 pReq->channels,
13392 pReq->channelCount);
13393 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
13394 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
13395 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
13396 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
13397 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
13398
13399 vos_mem_copy(pWdiOBSSScanInd->ieField,
13400 pReq->ieField,
13401 pReq->ieFieldLen);
13402
13403 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
13404 if (WDI_STATUS_PENDING == status)
13405 {
13406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13407 "Pending received for %s:%d ",__func__,__LINE__ );
13408 }
13409 else if (WDI_STATUS_SUCCESS_SYNC != status)
13410 {
13411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13412 "Failure in %s:%d ",__func__,__LINE__ );
13413 }
13414 return CONVERT_WDI2VOS_STATUS(status) ;
13415}
13416/*
13417 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
13418 *
13419 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
13420 *
13421 * PARAM:
13422 * pWDA: pointer to WDA context
13423 * pReq: pointer to stop batch scan request
13424 */
13425VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
13426 tANI_U8 *bssIdx)
13427{
13428 WDI_Status status;
13429
13430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13431 "------> %s " ,__func__);
13432
13433 status = WDI_HT40OBSSStopScanInd(*bssIdx);
13434 if (WDI_STATUS_PENDING == status)
13435 {
13436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13437 "Pending received for %s:%d ",__func__,__LINE__ );
13438 }
13439 else if (WDI_STATUS_SUCCESS_SYNC != status)
13440 {
13441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13442 "Failure in %s:%d ",__func__,__LINE__ );
13443 }
13444 return CONVERT_WDI2VOS_STATUS(status) ;
13445}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13446/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13447 * FUNCTION: WDA_ProcessRateUpdateInd
13448 *
13449 */
13450VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
13451 tSirRateUpdateInd *pRateUpdateParams)
13452{
13453 WDI_Status wdiStatus;
13454 WDI_RateUpdateIndParams rateUpdateParams;
13455
13456 vos_mem_copy(rateUpdateParams.bssid,
13457 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
13458
13459 rateUpdateParams.ucastDataRateTxFlag =
13460 pRateUpdateParams->ucastDataRateTxFlag;
13461 rateUpdateParams.reliableMcastDataRateTxFlag =
13462 pRateUpdateParams->reliableMcastDataRateTxFlag;
13463 rateUpdateParams.mcastDataRate24GHzTxFlag =
13464 pRateUpdateParams->mcastDataRate24GHzTxFlag;
13465 rateUpdateParams.mcastDataRate5GHzTxFlag =
13466 pRateUpdateParams->mcastDataRate5GHzTxFlag;
13467
13468 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
13469 rateUpdateParams.reliableMcastDataRate =
13470 pRateUpdateParams->reliableMcastDataRate;
13471 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
13472 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
13473
13474 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13475 rateUpdateParams.pUserData = pWDA;
13476
13477 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
13478
13479 if (WDI_STATUS_PENDING == wdiStatus)
13480 {
13481 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13482 "Pending received for %s:%d", __func__, __LINE__ );
13483 }
13484 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13485 {
13486 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13487 "Failure in %s:%d", __func__, __LINE__ );
13488 }
13489
13490 vos_mem_free(pRateUpdateParams);
13491
13492 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13493}
13494
13495/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13496 * -------------------------------------------------------------------------
13497 * DATA interface with WDI for Mgmt Frames
13498 * -------------------------------------------------------------------------
13499 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13500/*
13501 * FUNCTION: WDA_TxComplete
13502 * Callback function for the WDA_TxPacket
13503 */
13504VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
13505 VOS_STATUS status )
13506{
13507
13508 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
13509 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13510 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13511
Mihir Shete63341222015-03-24 15:39:18 +0530[diff] [blame]13512 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__);
13513
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13514 if(NULL == wdaContext)
13515 {
13516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13517 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13518 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13519 VOS_ASSERT(0);
Sushant Kaushik8355d202014-12-17 16:48:10 +0530[diff] [blame]13520 vos_pkt_return_packet(pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13521 return VOS_STATUS_E_FAILURE;
13522 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13523
13524 /*Check if frame was timed out or not*/
13525 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
13526 (v_PVOID_t)&uUserData);
13527
13528 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
13529 {
13530 /*Discard frame - no further processing is needed*/
Mihir Shete63341222015-03-24 15:39:18 +0530[diff] [blame]13531 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13532 "%s: MGMT Frame Tx timed out",
13533 __func__);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13534 vos_pkt_return_packet(pData);
13535 return VOS_STATUS_SUCCESS;
13536 }
13537
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13538 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
13539 if( NULL!=wdaContext->pTxCbFunc)
13540 {
13541 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]13542 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]13543 {
13544 wdaContext->pTxCbFunc(pMac, pData);
13545 }
13546 else
13547 {
13548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]13549 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13550 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13551 //Return from here since we reaching here because the packet already timeout
13552 return status;
13553 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13554 }
13555
13556 /*
13557 * Trigger the event to bring the HAL TL Tx complete function to come
13558 * out of wait
13559 * Let the coe above to complete the packet first. When this event is set,
13560 * the thread waiting for the event may run and set Vospacket_freed causing the original
13561 * packet not being freed.
13562 */
13563 status = vos_event_set(&wdaContext->txFrameEvent);
13564 if(!VOS_IS_STATUS_SUCCESS(status))
13565 {
13566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13567 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13568 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13569 return status;
13570}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13571/*
13572 * FUNCTION: WDA_TxPacket
13573 * Forward TX management frame to WDI
13574 */
13575VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
13576 void *pFrmBuf,
13577 tANI_U16 frmLen,
13578 eFrameType frmType,
13579 eFrameTxDir txDir,
13580 tANI_U8 tid,
13581 pWDATxRxCompFunc pCompFunc,
13582 void *pData,
13583 pWDAAckFnTxComp pAckTxComp,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13584 tANI_U32 txFlag,
13585 tANI_U32 txBdToken
13586 )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13587{
13588 VOS_STATUS status = VOS_STATUS_SUCCESS ;
13589 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
13590 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
13591 tANI_U8 eventIdx = 0;
13592 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
13593 tpAniSirGlobal pMac;
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]13594 tpSirTxBdStatus txBdStatus = {0};
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13595
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13596 if((NULL == pWDA)||(NULL == pFrmBuf))
13597 {
13598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]13599 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13600 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13601 VOS_ASSERT(0);
13602 return VOS_STATUS_E_FAILURE;
13603 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]13604
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13606 "Tx Mgmt Frame Subtype: %d alloc(%p) txBdToken = %u",
13607 pFc->subType, pFrmBuf, txBdToken);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13608 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13609 if(NULL == pMac)
13610 {
13611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13612 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13613 VOS_ASSERT(0);
13614 return VOS_STATUS_E_FAILURE;
13615 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]13616
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13617 /* store the call back function in WDA context */
13618 pWDA->pTxCbFunc = pCompFunc;
13619 /* store the call back for the function of ackTxComplete */
13620 if( pAckTxComp )
13621 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13622 if( NULL != pWDA->pAckTxCbFunc )
13623 {
13624 /* Already TxComp is active no need to active again */
Agarwal Ashish3b3f3cb2015-07-02 16:43:47 +0530[diff] [blame]13625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13626 "There is already one request pending for tx complete");
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]13627 pWDA->pAckTxCbFunc( pMac, &txBdStatus);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13628 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13629
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13630 if( VOS_STATUS_SUCCESS !=
13631 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13632 {
13633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13634 "Tx Complete timeout Timer Stop Failed ");
13635 }
13636 else
13637 {
Agarwal Ashish3b3f3cb2015-07-02 16:43:47 +0530[diff] [blame]13638 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]13639 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13640 }
13641 }
13642
13643 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
13644 pWDA->pAckTxCbFunc = pAckTxComp;
13645 if( VOS_STATUS_SUCCESS !=
13646 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
13647 {
13648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13649 "Tx Complete Timer Start Failed ");
13650 pWDA->pAckTxCbFunc = NULL;
13651 return eHAL_STATUS_FAILURE;
13652 }
13653 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13654 /* Reset the event to be not signalled */
13655 status = vos_event_reset(&pWDA->txFrameEvent);
13656 if(!VOS_IS_STATUS_SUCCESS(status))
13657 {
13658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13659 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13660 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
13661 if( pAckTxComp )
13662 {
13663 pWDA->pAckTxCbFunc = NULL;
13664 if( VOS_STATUS_SUCCESS !=
13665 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13666 {
13667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13668 "Tx Complete timeout Timer Stop Failed ");
13669 }
13670 }
13671 return VOS_STATUS_E_FAILURE;
13672 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]13673
13674 /* If Peer Sta mask is set don't overwrite to self sta */
13675 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13676 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]13677 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13678 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]13679 else
13680 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]13681 /* Get system role, use the self station if in unknown role or STA role */
13682 systemRole = wdaGetGlobalSystemRole(pMac);
13683 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
13684 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]13685#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]13686 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]13687#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]13688 ))
13689 {
13690 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
13691 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]13692 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13693
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13694 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
13695 disassoc frame reaches the HW, HAL has already deleted the peer station */
13696 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13697 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]13698 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13699 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13700 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13701 /*Send Probe request frames on self sta idx*/
13702 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13703 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13704 /* Since we donot want probe responses to be retried, send probe responses
13705 through the NO_ACK queues */
13706 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
13707 {
13708 //probe response is sent out using self station and no retries options.
13709 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
13710 }
13711 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
13712 {
13713 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
13714 }
13715 }
Pradeep Reddy POTTETI01710062015-06-29 13:35:53 +0530[diff] [blame]13716#ifdef FEATURE_WLAN_TDLS
13717 /* TDLS Management frames are sent using Peer Sta mask */
13718 else if ((pFc->type == SIR_MAC_DATA_FRAME) &&
13719 (txFlag & HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME))
13720 {
13721 txFlag |= HAL_USE_PEER_STA_REQUESTED_MASK;
13722
13723 }
13724#endif
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]13725 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]13726
13727 /*Set frame tag to 0
13728 We will use the WDA user data in order to tag a frame as expired*/
13729 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
13730 (v_PVOID_t)0);
13731
13732
13733 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13734 frmLen, ucTypeSubType, tid, WDA_TxComplete, NULL, txFlag,
13735 txBdToken))!= VOS_STATUS_SUCCESS)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13736 {
13737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13738 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13739 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]13740 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]13741 if( pAckTxComp )
13742 {
13743 pWDA->pAckTxCbFunc = NULL;
13744 if( VOS_STATUS_SUCCESS !=
13745 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13746 {
13747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13748 "Tx Complete timeout Timer Stop Failed ");
13749 }
13750 }
13751 return VOS_STATUS_E_FAILURE;
13752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13753 /*
13754 * Wait for the event to be set by the TL, to get the response of TX
13755 * complete, this event should be set by the Callback function called by TL
13756 */
13757 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
13758 &eventIdx);
13759 if(!VOS_IS_STATUS_SUCCESS(status))
13760 {
13761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13762 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13763 __func__, status);
Sushant Kaushik8355d202014-12-17 16:48:10 +0530[diff] [blame]13764
13765 /*Tag Frame as timed out for later deletion*/
13766 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
13767 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13768 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
13769 after the packet gets completed(packet freed once)*/
13770
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]13771 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame]13772 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]13773
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13774 /* check whether the packet was freed already,so need not free again when
13775 * TL calls the WDA_Txcomplete routine
13776 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]13777 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
13778 /*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]13779 {
13780 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13781 } */
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame^]13782 if (vos_isFatalEventEnabled())
13783 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
13784 WLAN_LOG_INDICATOR_HOST_DRIVER,
13785 WLAN_LOG_REASON_MGMT_FRAME_TIMEOUT,
13786 FALSE, TRUE);
13787 else
13788 VOS_BUG(0);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13789
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13790 if( pAckTxComp )
13791 {
13792 pWDA->pAckTxCbFunc = NULL;
13793 if( VOS_STATUS_SUCCESS !=
13794 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13795 {
13796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13797 "Tx Complete timeout Timer Stop Failed ");
13798 }
13799 }
13800 status = VOS_STATUS_E_FAILURE;
13801 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]13802#ifdef WLAN_DUMP_MGMTFRAMES
13803 if (VOS_IS_STATUS_SUCCESS(status))
13804 {
13805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13806 "%s() TX packet : SubType %d", __func__,pFc->subType);
13807 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13808 pData, frmLen);
13809 }
13810#endif
13811
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]13812 if (VOS_IS_STATUS_SUCCESS(status))
13813 {
13814 if (pMac->fEnableDebugLog & 0x1)
13815 {
13816 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
13817 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
13818 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
13819 {
13820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
13821 pFc->type, pFc->subType);
13822 }
13823 }
13824 }
13825
13826
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13827 return status;
13828}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13829/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13830 * FUNCTION: WDA_ProcessDHCPStartInd
13831 * Forward DHCP Start to WDI
13832 */
13833static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
13834 tAniDHCPInd *dhcpStartInd)
13835{
13836 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13837 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13838
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13839 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
13840 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13841 sizeof(tSirMacAddr));
13842
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13843 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13844
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13845 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13846 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13848 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13849 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13850 else if (WDI_STATUS_SUCCESS_SYNC != status)
13851 {
13852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13853 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
13854 }
13855
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13856 vos_mem_free(dhcpStartInd);
13857 return CONVERT_WDI2VOS_STATUS(status) ;
13858}
13859
13860 /*
13861 * FUNCTION: WDA_ProcessDHCPStopInd
13862 * Forward DHCP Stop to WDI
13863 */
13864 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
13865 tAniDHCPInd *dhcpStopInd)
13866 {
13867 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13868 WDI_DHCPInd wdiDHCPInd;
13869
13870 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
13871 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
13872
13873 status = WDI_dhcpStopInd(&wdiDHCPInd);
13874
13875 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13876 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13878 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13879 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13880 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13881 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13883 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13884 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13885
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13886 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]13887
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13888 return CONVERT_WDI2VOS_STATUS(status) ;
13889 }
13890
13891/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13892 * FUNCTION: WDA_ProcessSetSpoofMacAddrReq
13893 *
13894 * DESCRIPTION: This function sends Spoof Mac Addr Req to WDI
13895 *
13896 * PARAM:
13897 * pWDA: pointer to WDA context
13898 * pReq: pointer to stop batch scan request
13899 */
13900VOS_STATUS WDA_ProcessSetSpoofMacAddrReq(tWDA_CbContext *pWDA,
13901 tpSpoofMacAddrReqParams pReq)
13902{
13903 WDI_Status wdiStatus;
13904 WDI_SpoofMacAddrInfoType *WDI_SpoofMacAddrInfoParams;
13905 tWDA_ReqParams *pWdaParams;
13906
13907 WDI_SpoofMacAddrInfoParams = (WDI_SpoofMacAddrInfoType *)vos_mem_malloc(
13908 sizeof(WDI_SpoofMacAddrInfoType));
13909 if(NULL == WDI_SpoofMacAddrInfoParams) {
13910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13911 "%s: VOS MEM Alloc Failure in Spoof Req", __func__);
13912 VOS_ASSERT(0);
13913 return VOS_STATUS_E_NOMEM;
13914 }
13915 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
13916 if(NULL == pWdaParams) {
13917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13918 "%s: VOS MEM Alloc Failure", __func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]13919 vos_mem_free(WDI_SpoofMacAddrInfoParams);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13920 VOS_ASSERT(0);
13921 return VOS_STATUS_E_NOMEM;
13922 }
13923
13924 vos_mem_copy(WDI_SpoofMacAddrInfoParams->macAddr,
13925 pReq->macAddr, VOS_MAC_ADDRESS_LEN);
13926
13927 pWdaParams->pWdaContext = pWDA;
13928 /* Store Upper layer req pointer, as this will be used for response */
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]13929 pWdaParams->wdaMsgParam = (void *)pReq;
13930
13931 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, WDA_MAC_ADDRESS_STR,
13932 WDA_MAC_ADDR_ARRAY(WDI_SpoofMacAddrInfoParams->macAddr));
13933
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13934 /* store Params pass it to WDI */
13935 pWdaParams->wdaWdiApiMsgParam = (void *)WDI_SpoofMacAddrInfoParams ;
13936
13937 wdiStatus = WDI_SetSpoofMacAddrReq(WDI_SpoofMacAddrInfoParams,
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]13938 (WDI_SetSpoofMacAddrRspCb) WDA_SpoofMacAddrRspCallback,
13939 pWdaParams );
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13940
13941 if(IS_WDI_STATUS_FAILURE(wdiStatus))
13942 {
13943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13944 "Failure in SetSpoofMacAddrReq Params WDI API, free all the memory " );
13945 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
13946 vos_mem_free(pWdaParams->wdaMsgParam);
13947 vos_mem_free(pWdaParams);
13948 }
13949
13950 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
13951}
13952
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]13953
13954/*
13955 * FUNCTION: WDA_FwrMemDumpRespCallback
13956 * recieves Mgmt Logging init response from FW
13957 */
13958 void WDA_FwrMemDumpRespCallback(WDI_FwrMemDumpRsp* wdiRsp,
13959 void* pUserData)
13960{
13961 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13962 tAniFwrDumpReq *pFwrMemDumpReq;
13963 tAniFwrDumpRsp *pFwrMemDumpRsp;
13964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13965 "<------ %s " ,__func__);
13966
13967 if(NULL == pWdaParams)
13968 {
13969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13970 "%s: pWdaParams received NULL", __func__);
13971 VOS_ASSERT(0);
13972 return ;
13973 }
13974
13975 if(NULL == pWdaParams->wdaMsgParam)
13976 {
13977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13978 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
13979 VOS_ASSERT(0);
13980 vos_mem_free(pWdaParams);
13981 return ;
13982 }
13983
13984 pFwrMemDumpRsp = (tAniFwrDumpRsp *)vos_mem_malloc(sizeof(tAniFwrDumpRsp));
13985 if(pFwrMemDumpRsp == NULL)
13986 {
13987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13988 "%s: pFwrMemDumpRsp is NULL", __func__);
13989 VOS_ASSERT(0);
13990 vos_mem_free(pWdaParams);
13991 return ;
13992 }
13993
13994 pFwrMemDumpRsp->dump_status = wdiRsp->dump_status;
13995 pFwrMemDumpReq = (tAniFwrDumpReq *)pWdaParams->wdaMsgParam;
13996
13997 if(pFwrMemDumpReq->fwMemDumpReqCallback)
13998 {
13999 pFwrMemDumpReq->fwMemDumpReqCallback(
14000 pFwrMemDumpReq->fwMemDumpReqContext,
14001 pFwrMemDumpRsp);
14002 }
14003 else
14004 {
14005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14006 "%s: FwrMemDump callback is NULL", __func__);
14007 }
14008
14009 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14010 vos_mem_free(pWdaParams->wdaMsgParam);
14011 vos_mem_free(pWdaParams);
14012 vos_mem_free(pFwrMemDumpRsp);
14013
14014 return ;
14015}
14016
14017VOS_STATUS WDA_ProcessFwrMemDumpReq(tWDA_CbContext * pWDA,
14018 tAniFwrDumpReq* pFwrMemDumpReq)
14019{
14020 VOS_STATUS status = VOS_STATUS_SUCCESS;
14021 WDI_Status wstatus;
14022 WDI_FwrMemDumpReqType * pWdiFwrMemDumpReq;
14023 tWDA_ReqParams *pWdaParams ;
14024
14025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14026 "------> %s " ,__func__);
14027 /* Sanity Check*/
14028 if(NULL == pFwrMemDumpReq)
14029 {
14030 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14031 "%s: pFwrMemDumpReq received NULL", __func__);
14032 VOS_ASSERT(0) ;
14033 return VOS_STATUS_E_FAULT;
14034 }
14035
14036 pWdiFwrMemDumpReq = (WDI_FwrMemDumpReqType *)vos_mem_malloc(sizeof(WDI_FwrMemDumpReqType));
14037 if(NULL == pWdiFwrMemDumpReq)
14038 {
14039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14040 "%s: pWdiFwrMemDumpReq Alloc Failure", __func__);
14041 VOS_ASSERT(0);
14042 return VOS_STATUS_E_NOMEM;
14043 }
14044
14045 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14046 if(NULL == pWdaParams)
14047 {
14048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14049 "%s: pWdaParams Alloc Failure", __func__);
14050 VOS_ASSERT(0);
14051 vos_mem_free(pWdiFwrMemDumpReq);
14052 return VOS_STATUS_E_NOMEM;
14053 }
14054
14055 /* Store Params pass it to WDI */
14056 pWdaParams->wdaWdiApiMsgParam = (void *)pWdiFwrMemDumpReq;
14057 pWdaParams->pWdaContext = pWDA;
14058 /* Store param pointer as passed in by caller */
14059 pWdaParams->wdaMsgParam = pFwrMemDumpReq;
14060
14061 status = WDI_FwrMemDumpReq(pWdiFwrMemDumpReq,
14062 (WDI_FwrMemDumpCb)WDA_FwrMemDumpRespCallback,
14063 pWdaParams);
14064
14065 if(IS_WDI_STATUS_FAILURE(wstatus))
14066 {
14067 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14068 FL("Fwr Mem Dump Req failed, free all the memory"));
14069 status = CONVERT_WDI2VOS_STATUS(wstatus);
14070 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14071 vos_mem_free(pWdaParams->wdaMsgParam);
14072 vos_mem_free(pWdaParams);
14073 pWdaParams->wdaWdiApiMsgParam = NULL;
14074 pWdaParams->wdaMsgParam = NULL;
14075 }
14076
14077 return status;
14078
14079}
14080
14081
14082
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14083/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14084 * FUNCTION: WDA_McProcessMsg
14085 * Trigger DAL-AL to start CFG download
14086 */
14087VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
14088{
14089 VOS_STATUS status = VOS_STATUS_SUCCESS;
14090 tWDA_CbContext *pWDA = NULL ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14091 if(NULL == pMsg)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14092 {
14093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14094 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14095 VOS_ASSERT(0);
14096 return VOS_STATUS_E_FAILURE;
14097 }
14098
14099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14100 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14101
14102 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
14103 if(NULL == pWDA )
14104 {
14105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14106 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14107 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]14108 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14109 return VOS_STATUS_E_FAILURE;
14110 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14111 /* Process all the WDA messages.. */
14112 switch( pMsg->type )
14113 {
14114 case WNI_CFG_DNLD_REQ:
14115 {
14116 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14117 /* call WDA complete event if config download success */
14118 if( VOS_IS_STATUS_SUCCESS(status) )
14119 {
14120 vos_WDAComplete_cback(pVosContext);
14121 }
14122 else
14123 {
14124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14125 "WDA Config Download failure" );
14126 }
14127 break ;
14128 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14129 /*
14130 * Init SCAN request from PE, convert it into DAL format
14131 * and send it to DAL
14132 */
14133 case WDA_INIT_SCAN_REQ:
14134 {
14135 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
14136 break ;
14137 }
14138 /* start SCAN request from PE */
14139 case WDA_START_SCAN_REQ:
14140 {
14141 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
14142 break ;
14143 }
14144 /* end SCAN request from PE */
14145 case WDA_END_SCAN_REQ:
14146 {
14147 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
14148 break ;
14149 }
14150 /* end SCAN request from PE */
14151 case WDA_FINISH_SCAN_REQ:
14152 {
14153 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
14154 break ;
14155 }
14156 /* join request from PE */
14157 case WDA_CHNL_SWITCH_REQ:
14158 {
14159 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
14160 {
14161 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
14162 }
14163 else
14164 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]14165 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
14166 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
14167 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
14168 {
14169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14170 "call ProcessChannelSwitchReq_V1" );
14171 WDA_ProcessChannelSwitchReq_V1(pWDA,
14172 (tSwitchChannelParams*)pMsg->bodyptr) ;
14173 }
14174 else
14175 {
14176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14177 "call ProcessChannelSwitchReq" );
14178 WDA_ProcessChannelSwitchReq(pWDA,
14179 (tSwitchChannelParams*)pMsg->bodyptr) ;
14180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14181 }
14182 break ;
14183 }
14184 /* ADD BSS request from PE */
14185 case WDA_ADD_BSS_REQ:
14186 {
14187 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
14188 break ;
14189 }
14190 case WDA_ADD_STA_REQ:
14191 {
14192 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
14193 break ;
14194 }
14195 case WDA_DELETE_BSS_REQ:
14196 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14197 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
14198 break ;
14199 }
14200 case WDA_DELETE_STA_REQ:
14201 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14202 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
14203 break ;
14204 }
14205 case WDA_CONFIG_PARAM_UPDATE_REQ:
14206 {
14207 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
14208 break ;
14209 }
14210 case WDA_SET_BSSKEY_REQ:
14211 {
14212 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
14213 break ;
14214 }
14215 case WDA_SET_STAKEY_REQ:
14216 {
14217 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
14218 break ;
14219 }
14220 case WDA_SET_STA_BCASTKEY_REQ:
14221 {
14222 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
14223 break ;
14224 }
14225 case WDA_REMOVE_BSSKEY_REQ:
14226 {
14227 WDA_ProcessRemoveBssKeyReq(pWDA,
14228 (tRemoveBssKeyParams *)pMsg->bodyptr);
14229 break ;
14230 }
14231 case WDA_REMOVE_STAKEY_REQ:
14232 {
14233 WDA_ProcessRemoveStaKeyReq(pWDA,
14234 (tRemoveStaKeyParams *)pMsg->bodyptr);
14235 break ;
14236 }
14237 case WDA_REMOVE_STA_BCASTKEY_REQ:
14238 {
14239 /* TODO: currently UMAC is not sending this request, Add the code for
14240 handling this request when UMAC supports */
14241 break;
14242 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14243#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14244 case WDA_TSM_STATS_REQ:
14245 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]14246 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14247 break;
14248 }
14249#endif
14250 case WDA_UPDATE_EDCA_PROFILE_IND:
14251 {
14252 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
14253 break;
14254 }
14255 case WDA_ADD_TS_REQ:
14256 {
14257 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
14258 break;
14259 }
14260 case WDA_DEL_TS_REQ:
14261 {
14262 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
14263 break;
14264 }
14265 case WDA_ADDBA_REQ:
14266 {
14267 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
14268 break;
14269 }
14270 case WDA_DELBA_IND:
14271 {
14272 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
14273 break;
14274 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]14275 case WDA_UPDATE_CHAN_LIST_REQ:
14276 {
14277 WDA_ProcessUpdateChannelList(pWDA,
14278 (tSirUpdateChanList *)pMsg->bodyptr);
14279 break;
14280 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14281 case WDA_SET_LINK_STATE:
14282 {
14283 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
14284 break;
14285 }
14286 case WDA_GET_STATISTICS_REQ:
14287 {
14288 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
14289 break;
14290 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14291#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]14292 case WDA_GET_ROAM_RSSI_REQ:
14293 {
14294 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
14295 break;
14296 }
14297#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14298 case WDA_PWR_SAVE_CFG:
14299 {
14300 if(pWDA->wdaState == WDA_READY_STATE)
14301 {
14302 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
14303 }
14304 else
14305 {
14306 if(NULL != pMsg->bodyptr)
14307 {
14308 vos_mem_free(pMsg->bodyptr);
14309 }
14310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14311 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
14312 }
14313 break;
14314 }
14315 case WDA_ENTER_IMPS_REQ:
14316 {
14317 if(pWDA->wdaState == WDA_READY_STATE)
14318 {
14319 WDA_ProcessEnterImpsReq(pWDA);
14320 }
14321 else
14322 {
14323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14324 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
14325 }
14326 break;
14327 }
14328 case WDA_EXIT_IMPS_REQ:
14329 {
14330 if(pWDA->wdaState == WDA_READY_STATE)
14331 {
14332 WDA_ProcessExitImpsReq(pWDA);
14333 }
14334 else
14335 {
14336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14337 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
14338 }
14339 break;
14340 }
14341 case WDA_ENTER_BMPS_REQ:
14342 {
14343 if(pWDA->wdaState == WDA_READY_STATE)
14344 {
14345 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
14346 }
14347 else
14348 {
14349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14350 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
14351 }
14352 break;
14353 }
14354 case WDA_EXIT_BMPS_REQ:
14355 {
14356 if(pWDA->wdaState == WDA_READY_STATE)
14357 {
14358 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
14359 }
14360 else
14361 {
14362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14363 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
14364 }
14365 break;
14366 }
14367 case WDA_ENTER_UAPSD_REQ:
14368 {
14369 if(pWDA->wdaState == WDA_READY_STATE)
14370 {
14371 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
14372 }
14373 else
14374 {
14375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14376 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
14377 }
14378 break;
14379 }
14380 case WDA_EXIT_UAPSD_REQ:
14381 {
14382 if(pWDA->wdaState == WDA_READY_STATE)
14383 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]14384 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14385 }
14386 else
14387 {
14388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14389 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
14390 }
14391 break;
14392 }
14393 case WDA_UPDATE_UAPSD_IND:
14394 {
14395 if(pWDA->wdaState == WDA_READY_STATE)
14396 {
14397 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
14398 }
14399 else
14400 {
14401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14402 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
14403 }
14404 break;
14405 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14406 case WDA_REGISTER_PE_CALLBACK :
14407 {
14408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14409 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
14410 /*TODO: store the PE callback */
14411 /* Do Nothing? MSG Body should be freed at here */
14412 if(NULL != pMsg->bodyptr)
14413 {
14414 vos_mem_free(pMsg->bodyptr);
14415 }
14416 break;
14417 }
14418 case WDA_SYS_READY_IND :
14419 {
14420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14421 "Handling msg type WDA_SYS_READY_IND " );
14422 pWDA->wdaState = WDA_READY_STATE;
14423 if(NULL != pMsg->bodyptr)
14424 {
14425 vos_mem_free(pMsg->bodyptr);
14426 }
14427 break;
14428 }
14429 case WDA_BEACON_FILTER_IND :
14430 {
14431 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
14432 break;
14433 }
14434 case WDA_BTC_SET_CFG:
14435 {
14436 /*TODO: handle this while dealing with BTC */
14437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14438 "Handling msg type WDA_BTC_SET_CFG " );
14439 /* Do Nothing? MSG Body should be freed at here */
14440 if(NULL != pMsg->bodyptr)
14441 {
14442 vos_mem_free(pMsg->bodyptr);
14443 }
14444 break;
14445 }
14446 case WDA_SIGNAL_BT_EVENT:
14447 {
14448 /*TODO: handle this while dealing with BTC */
14449 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14450 "Handling msg type WDA_SIGNAL_BT_EVENT " );
14451 /* Do Nothing? MSG Body should be freed at here */
14452 if(NULL != pMsg->bodyptr)
14453 {
14454 vos_mem_free(pMsg->bodyptr);
14455 }
14456 break;
14457 }
14458 case WDA_CFG_RXP_FILTER_REQ:
14459 {
14460 WDA_ProcessConfigureRxpFilterReq(pWDA,
14461 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
14462 break;
14463 }
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]14464 case WDA_MGMT_LOGGING_INIT_REQ:
14465 {
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]14466 WDA_ProcessFWLoggingInitReq(pWDA,
14467 (tSirFWLoggingInitParam *)pMsg->bodyptr);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]14468 break;
14469 }
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]14470 case WDA_GET_FRAME_LOG_REQ:
14471 {
14472 WDA_ProcessGetFrameLogReq(pWDA,
14473 (tAniGetFrameLogReq *)pMsg->bodyptr);
14474 break;
14475 }
Karthick Sa35b0692015-08-21 15:57:05 +0530[diff] [blame]14476 case WDA_SEND_LOG_DONE_IND:
14477 {
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]14478 WDA_FWLoggingDXEdoneInd(pMsg->bodyval);
Karthick Sa35b0692015-08-21 15:57:05 +0530[diff] [blame]14479 break;
14480 }
Sachin Ahuja715aafc2015-07-21 23:35:10 +0530[diff] [blame]14481 case WDA_FATAL_EVENT_LOGS_REQ:
14482 {
14483 WDA_ProcessFatalEventLogsReq(pWDA,
14484 (tSirFatalEventLogsReqParam *)pMsg->bodyptr);
14485 break;
14486 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14487 case WDA_SET_HOST_OFFLOAD:
14488 {
14489 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
14490 break;
14491 }
14492 case WDA_SET_KEEP_ALIVE:
14493 {
14494 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
14495 break;
14496 }
14497#ifdef WLAN_NS_OFFLOAD
14498 case WDA_SET_NS_OFFLOAD:
14499 {
14500 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
14501 break;
14502 }
14503#endif //WLAN_NS_OFFLOAD
14504 case WDA_ADD_STA_SELF_REQ:
14505 {
14506 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
14507 break;
14508 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14509 case WDA_DEL_STA_SELF_REQ:
14510 {
14511 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
14512 break;
14513 }
14514 case WDA_WOWL_ADD_BCAST_PTRN:
14515 {
14516 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
14517 break;
14518 }
14519 case WDA_WOWL_DEL_BCAST_PTRN:
14520 {
14521 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
14522 break;
14523 }
14524 case WDA_WOWL_ENTER_REQ:
14525 {
14526 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
14527 break;
14528 }
14529 case WDA_WOWL_EXIT_REQ:
14530 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]14531 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14532 break;
14533 }
14534 case WDA_TL_FLUSH_AC_REQ:
14535 {
14536 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
14537 break;
14538 }
14539 case WDA_SIGNAL_BTAMP_EVENT:
14540 {
14541 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
14542 break;
14543 }
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]14544 case WDA_FW_STATS_GET_REQ:
14545 {
14546 WDA_ProcessFWStatsGetReq(pWDA,
14547 (tSirFWStatsGetReq *)pMsg->bodyptr);
14548 break;
14549 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]14550#ifdef WLAN_FEATURE_LINK_LAYER_STATS
14551 case WDA_LINK_LAYER_STATS_SET_REQ:
14552 {
14553 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
14554 break;
14555 }
14556 case WDA_LINK_LAYER_STATS_GET_REQ:
14557 {
14558 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
14559 break;
14560 }
14561 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
14562 {
14563 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
14564 break;
14565 }
14566#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14567#ifdef WLAN_FEATURE_EXTSCAN
14568 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
14569 {
14570 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
14571 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
14572 break;
14573 }
14574 case WDA_EXTSCAN_START_REQ:
14575 {
14576 WDA_ProcessEXTScanStartReq(pWDA,
14577 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
14578 break;
14579 }
14580 case WDA_EXTSCAN_STOP_REQ:
14581 {
14582 WDA_ProcessEXTScanStopReq(pWDA,
14583 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
14584 break;
14585 }
14586 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
14587 {
14588 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
14589 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
14590 break;
14591 }
14592 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
14593 {
14594 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
14595 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
14596 break;
14597 }
14598 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
14599 {
14600 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
14601 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
14602 break;
14603 }
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]14604 case WDA_EXTSCAN_SET_SSID_HOTLIST_REQ:
14605 {
14606 WDA_ProcessEXTScanSetSSIDHotlistReq(pWDA,
14607 (tSirEXTScanSetSsidHotListReqParams *)pMsg->bodyptr);
14608 break;
14609 }
14610 case WDA_EXTSCAN_RESET_SSID_HOTLIST_REQ:
14611 {
14612 WDA_ProcessEXTScanResetSSIDHotlistReq(pWDA,
14613 (tSirEXTScanResetSsidHotlistReqParams *)pMsg->bodyptr);
14614 break;
14615 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14616#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14617#ifdef WDA_UT
14618 case WDA_WDI_EVENT_MSG:
14619 {
14620 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
14621 break ;
14622 }
14623#endif
14624 case WDA_UPDATE_BEACON_IND:
14625 {
14626 WDA_ProcessUpdateBeaconParams(pWDA,
14627 (tUpdateBeaconParams *)pMsg->bodyptr);
14628 break;
14629 }
14630 case WDA_SEND_BEACON_REQ:
14631 {
14632 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
14633 break;
14634 }
14635 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
14636 {
14637 WDA_ProcessUpdateProbeRspTemplate(pWDA,
14638 (tSendProbeRespParams *)pMsg->bodyptr);
14639 break;
14640 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14641#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14642 case WDA_SET_MAX_TX_POWER_REQ:
14643 {
14644 WDA_ProcessSetMaxTxPowerReq(pWDA,
14645 (tMaxTxPowerParams *)pMsg->bodyptr);
14646 break;
14647 }
14648#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]14649 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
14650 {
14651 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
14652 pMsg->bodyptr);
14653 break;
14654 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]14655 case WDA_SET_TX_POWER_REQ:
14656 {
14657 WDA_ProcessSetTxPowerReq(pWDA,
14658 (tSirSetTxPowerReq *)pMsg->bodyptr);
14659 break;
14660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14661 case WDA_SET_P2P_GO_NOA_REQ:
14662 {
14663 WDA_ProcessSetP2PGONOAReq(pWDA,
14664 (tP2pPsParams *)pMsg->bodyptr);
14665 break;
14666 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14667 /* timer related messages */
14668 case WDA_TIMER_BA_ACTIVITY_REQ:
14669 {
14670 WDA_BaCheckActivity(pWDA) ;
14671 break ;
14672 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14673
14674 /* timer related messages */
14675 case WDA_TIMER_TRAFFIC_STATS_IND:
14676 {
14677 WDA_TimerTrafficStatsInd(pWDA);
14678 break;
14679 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14680#ifdef WLAN_FEATURE_VOWIFI_11R
14681 case WDA_AGGR_QOS_REQ:
14682 {
14683 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
14684 break;
14685 }
14686#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14687 case WDA_FTM_CMD_REQ:
14688 {
14689 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
14690 break ;
14691 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14692#ifdef FEATURE_OEM_DATA_SUPPORT
14693 case WDA_START_OEM_DATA_REQ:
14694 {
14695 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
14696 break;
14697 }
14698#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14699 /* Tx Complete Time out Indication */
14700 case WDA_TX_COMPLETE_TIMEOUT_IND:
14701 {
14702 WDA_ProcessTxCompleteTimeOutInd(pWDA);
14703 break;
14704 }
14705 case WDA_WLAN_SUSPEND_IND:
14706 {
14707 WDA_ProcessWlanSuspendInd(pWDA,
14708 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
14709 break;
14710 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14711 case WDA_WLAN_RESUME_REQ:
14712 {
14713 WDA_ProcessWlanResumeReq(pWDA,
14714 (tSirWlanResumeParam *)pMsg->bodyptr) ;
14715 break;
14716 }
14717
14718 case WDA_UPDATE_CF_IND:
14719 {
14720 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
14721 pMsg->bodyptr = NULL;
14722 break;
14723 }
14724#ifdef FEATURE_WLAN_SCAN_PNO
14725 case WDA_SET_PNO_REQ:
14726 {
14727 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
14728 break;
14729 }
14730 case WDA_UPDATE_SCAN_PARAMS_REQ:
14731 {
14732 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
14733 break;
14734 }
14735 case WDA_SET_RSSI_FILTER_REQ:
14736 {
14737 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
14738 break;
14739 }
14740#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14741#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14742 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14743 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14744 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14745 break;
14746 }
14747#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14748 case WDA_SET_TX_PER_TRACKING_REQ:
14749 {
14750 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
14751 break;
14752 }
14753
14754#ifdef WLAN_FEATURE_PACKET_FILTERING
14755 case WDA_8023_MULTICAST_LIST_REQ:
14756 {
14757 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
14758 break;
14759 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14760 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
14761 {
14762 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
14763 break;
14764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14765 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
14766 {
14767 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
14768 break;
14769 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14770 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
14771 {
14772 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
14773 break;
14774 }
14775#endif // WLAN_FEATURE_PACKET_FILTERING
14776
14777
14778 case WDA_TRANSMISSION_CONTROL_IND:
14779 {
14780 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
14781 break;
14782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14783 case WDA_SET_POWER_PARAMS_REQ:
14784 {
14785 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
14786 break;
14787 }
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]14788 case WDA_FW_MEM_DUMP_REQ:
14789 {
14790 WDA_ProcessFwrMemDumpReq(pWDA, (tAniFwrDumpReq*)pMsg->bodyptr);
14791 break;
14792 }
14793
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14794#ifdef WLAN_FEATURE_GTK_OFFLOAD
14795 case WDA_GTK_OFFLOAD_REQ:
14796 {
14797 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
14798 break;
14799 }
14800
14801 case WDA_GTK_OFFLOAD_GETINFO_REQ:
14802 {
14803 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
14804 break;
14805 }
14806#endif //WLAN_FEATURE_GTK_OFFLOAD
14807
14808 case WDA_SET_TM_LEVEL_REQ:
14809 {
14810 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
14811 break;
14812 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]14813
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]14814 case WDA_UPDATE_OP_MODE:
14815 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]14816 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
14817 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
14818 {
14819 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
14820 }
14821 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]14822 {
14823 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
14824 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
14825 else
14826 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14827 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]14828 }
14829 else
14830 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14831 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]14832 break;
14833 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]14834#ifdef WLAN_FEATURE_11W
14835 case WDA_EXCLUDE_UNENCRYPTED_IND:
14836 {
14837 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
14838 break;
14839 }
14840#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]14841#ifdef FEATURE_WLAN_TDLS
14842 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
14843 {
14844 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
14845 break;
14846 }
14847#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14848 case WDA_DHCP_START_IND:
14849 {
14850 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
14851 break;
14852 }
14853 case WDA_DHCP_STOP_IND:
14854 {
14855 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
14856 break;
14857 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]14858#ifdef FEATURE_WLAN_LPHB
14859 case WDA_LPHB_CONF_REQ:
14860 {
14861 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
14862 break;
14863 }
14864#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]14865 case WDA_ADD_PERIODIC_TX_PTRN_IND:
14866 {
14867 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
14868 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
14869 break;
14870 }
14871 case WDA_DEL_PERIODIC_TX_PTRN_IND:
14872 {
14873 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
14874 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
14875 break;
14876 }
14877
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]14878#ifdef FEATURE_WLAN_BATCH_SCAN
14879 case WDA_SET_BATCH_SCAN_REQ:
14880 {
14881 WDA_ProcessSetBatchScanReq(pWDA,
14882 (tSirSetBatchScanReq *)pMsg->bodyptr);
14883 break;
14884 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]14885 case WDA_RATE_UPDATE_IND:
14886 {
14887 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
14888 break;
14889 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]14890 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
14891 {
14892 WDA_ProcessTriggerBatchScanResultInd(pWDA,
14893 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
14894 break;
14895 }
14896 case WDA_STOP_BATCH_SCAN_IND:
14897 {
14898 WDA_ProcessStopBatchScanInd(pWDA,
14899 (tSirStopBatchScanInd *)pMsg->bodyptr);
14900 break;
14901 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]14902 case WDA_GET_BCN_MISS_RATE_REQ:
14903 WDA_ProcessGetBcnMissRateReq(pWDA,
14904 (tSirBcnMissRateReq *)pMsg->bodyptr);
14905 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]14906#endif
14907
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]14908 case WDA_HT40_OBSS_SCAN_IND:
14909 {
14910 WDA_ProcessHT40OBSSScanInd(pWDA,
14911 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
14912 break;
14913 }
14914 case WDA_HT40_OBSS_STOP_SCAN_IND:
14915 {
14916 WDA_ProcessHT40OBSSStopScanInd(pWDA,
14917 (tANI_U8*)pMsg->bodyptr);
14918 break;
14919 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]14920// tdlsoffchan
14921#ifdef FEATURE_WLAN_TDLS
14922 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
14923 {
14924 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
14925 break;
14926 }
14927#endif
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14928 case WDA_SPOOF_MAC_ADDR_REQ:
14929 {
14930 WDA_ProcessSetSpoofMacAddrReq(pWDA, (tpSpoofMacAddrReqParams)pMsg->bodyptr);
14931 break;
14932 }
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]14933 case WDA_ENCRYPT_MSG_REQ:
14934 {
14935 WDA_ProcessEncryptMsgReq(pWDA, (u8 *)pMsg->bodyptr);
14936 break;
14937 }
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]14938
14939 case WDA_NAN_REQUEST:
14940 {
14941 WDA_ProcessNanRequest( pWDA, (tNanRequest *)pMsg->bodyptr);
14942 break;
14943 }
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]14944 case WDA_SET_RTS_CTS_HTVHT:
14945 {
14946 WDA_ProcessSetRtsCtsHTVhtInd( pWDA, pMsg->bodyval);
14947 break;
14948 }
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]14949
14950 case WDA_MON_START_REQ:
14951 {
14952 WDA_ProcessMonStartReq(pWDA,(v_PVOID_t)pMsg->bodyptr);
14953 break;
14954 }
14955 case WDA_MON_STOP_REQ:
14956 {
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]14957 WDA_ProcessMonStopReq(pWDA, (v_PVOID_t)pMsg->bodyptr);
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]14958 break;
14959 }
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]14960 case WDA_SEND_FREQ_RANGE_CONTROL_IND:
14961 {
14962 WDA_ProcessEnableDisableCAEventInd(pWDA, pMsg->bodyval);
14963 break;
14964 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14965 default:
14966 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]14967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14968 "No Handling for msg type %x in WDA "
14969 ,pMsg->type);
14970 /* Do Nothing? MSG Body should be freed at here */
14971 if(NULL != pMsg->bodyptr)
14972 {
14973 vos_mem_free(pMsg->bodyptr);
14974 }
14975 //WDA_VOS_ASSERT(0) ;
14976 }
14977 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14978 return status ;
14979}
14980
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14981/*
14982 * FUNCTION: WDA_LowLevelIndCallback
14983 * IND API callback from WDI, send Ind to PE
14984 */
14985void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
14986 void* pUserData )
14987{
14988 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
14989#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
14990 tSirRSSINotification rssiNotification;
14991#endif
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14992 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14993 {
14994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14995 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14996 VOS_ASSERT(0);
14997 return ;
14998 }
14999
15000 switch(wdiLowLevelInd->wdiIndicationType)
15001 {
15002 case WDI_RSSI_NOTIFICATION_IND:
15003 {
15004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15005 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15006#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
15007 rssiNotification.bReserved =
15008 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
15009 rssiNotification.bRssiThres1NegCross =
15010 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
15011 rssiNotification.bRssiThres1PosCross =
15012 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
15013 rssiNotification.bRssiThres2NegCross =
15014 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
15015 rssiNotification.bRssiThres2PosCross =
15016 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
15017 rssiNotification.bRssiThres3NegCross =
15018 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
15019 rssiNotification.bRssiThres3PosCross =
15020 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]15021 rssiNotification.avgRssi = (v_S7_t)
15022 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15023 WLANTL_BMPSRSSIRegionChangedNotification(
15024 pWDA->pVosContext,
15025 &rssiNotification);
15026#endif
15027 break ;
15028 }
15029 case WDI_MISSED_BEACON_IND:
15030 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]15031 tpSirSmeMissedBeaconInd pMissBeacInd =
15032 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15034 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15035 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]15036 if(NULL == pMissBeacInd)
15037 {
15038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15039 "%s: VOS MEM Alloc Failure", __func__);
15040 break;
15041 }
15042 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
15043 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
15044 pMissBeacInd->bssIdx =
15045 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
15046 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15047 break ;
15048 }
15049 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
15050 {
15051 /* TODO: Decode Ind and send Ind to PE */
15052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15053 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
15054 break ;
15055 }
15056
15057 case WDI_MIC_FAILURE_IND:
15058 {
15059 tpSirSmeMicFailureInd pMicInd =
15060 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
15061
15062 if(NULL == pMicInd)
15063 {
15064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15065 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15066 break;
15067 }
15068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15069 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15070 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
15071 pMicInd->length = sizeof(tSirSmeMicFailureInd);
15072 vos_mem_copy(pMicInd->bssId,
15073 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
15074 sizeof(tSirMacAddr));
15075 vos_mem_copy(pMicInd->info.srcMacAddr,
15076 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
15077 sizeof(tSirMacAddr));
15078 vos_mem_copy(pMicInd->info.taMacAddr,
15079 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
15080 sizeof(tSirMacAddr));
15081 vos_mem_copy(pMicInd->info.dstMacAddr,
15082 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
15083 sizeof(tSirMacAddr));
15084 vos_mem_copy(pMicInd->info.rxMacAddr,
15085 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
15086 sizeof(tSirMacAddr));
15087 pMicInd->info.multicast =
15088 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
15089 pMicInd->info.keyId=
15090 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
15091 pMicInd->info.IV1=
15092 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
15093 vos_mem_copy(pMicInd->info.TSC,
15094 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15095 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
15096 (void *)pMicInd , 0) ;
15097 break ;
15098 }
15099 case WDI_FATAL_ERROR_IND:
15100 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]15101 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15102 /* TODO: Decode Ind and send Ind to PE */
15103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15104 "Received WDI_FATAL_ERROR_IND from WDI ");
15105 break ;
15106 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15107 case WDI_DEL_STA_IND:
15108 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15109 tpDeleteStaContext pDelSTACtx =
15110 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
15111
15112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15113 "Received WDI_DEL_STA_IND from WDI ");
15114 if(NULL == pDelSTACtx)
15115 {
15116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15117 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15118 break;
15119 }
15120 vos_mem_copy(pDelSTACtx->addr2,
15121 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
15122 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15123 vos_mem_copy(pDelSTACtx->bssId,
15124 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
15125 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15126 pDelSTACtx->assocId =
15127 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
15128 pDelSTACtx->reasonCode =
15129 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
15130 pDelSTACtx->staId =
15131 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15132 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
15133 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15134 break ;
15135 }
15136 case WDI_COEX_IND:
15137 {
15138 tANI_U32 index;
15139 vos_msg_t vosMsg;
c_hpothub3458992014-09-19 19:58:57 +0530[diff] [blame]15140 tSirSmeCoexInd *pSmeCoexInd;
15141
15142 if (SIR_COEX_IND_TYPE_CXM_FEATURES_NOTIFICATION ==
15143 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType)
15144 {
15145 if(wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData)
15146 {
15147 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15148 FL("Coex state: 0x%x coex feature: 0x%x"),
15149 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[0],
15150 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[1]);
15151
15152 if (wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[2] << 16)
15153 {
15154 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, FL("power limit: 0x%x"),
15155 (tANI_U16)(wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[2]));
15156 }
15157 }
15158 break;
15159 }
15160
15161 pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15162 if(NULL == pSmeCoexInd)
15163 {
15164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15165 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15166 break;
15167 }
15168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15169 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15170 /* Message Header */
15171 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
15172 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15173 /* Info from WDI Indication */
15174 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
15175 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
15176 {
15177 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
15178 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15179 /* VOS message wrapper */
15180 vosMsg.type = eWNI_SME_COEX_IND;
15181 vosMsg.bodyptr = (void *)pSmeCoexInd;
15182 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15183 /* Send message to SME */
15184 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15185 {
15186 /* free the mem and return */
15187 vos_mem_free((v_VOID_t *)pSmeCoexInd);
15188 }
15189 else
15190 {
15191 /* DEBUG */
15192 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15193 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
15194 pSmeCoexInd->coexIndType,
15195 pSmeCoexInd->coexIndData[0],
15196 pSmeCoexInd->coexIndData[1],
15197 pSmeCoexInd->coexIndData[2],
15198 pSmeCoexInd->coexIndData[3]);
15199 }
15200 break;
15201 }
15202 case WDI_TX_COMPLETE_IND:
15203 {
15204 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
15205 /* Calling TxCompleteAck Indication from wda context*/
15206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15207 "Complete Indication received from HAL");
15208 if( pWDA->pAckTxCbFunc )
15209 {
15210 if( VOS_STATUS_SUCCESS !=
15211 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
15212 {
15213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15214 "Tx Complete timeout Timer Stop Failed ");
Ganesh Kondabattinib18b3292015-03-16 16:59:26 +0530[diff] [blame]15215 }
Ganesh Kondabattinie1accae2015-06-11 17:18:00 +0530[diff] [blame]15216 if (!IS_FEATURE_SUPPORTED_BY_FW(ENHANCED_TXBD_COMPLETION))
Ganesh Kondabattinib18b3292015-03-16 16:59:26 +0530[diff] [blame]15217 pWDA->pAckTxCbFunc( pMac, &wdiLowLevelInd->wdiIndicationData.tx_complete_status);
15218 else
15219 pWDA->pAckTxCbFunc( pMac, &wdiLowLevelInd->wdiIndicationData.wdiTxBdInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15220 pWDA->pAckTxCbFunc = NULL;
15221 }
15222 else
15223 {
Ratheesh S P36dbc932015-08-07 14:28:57 +0530[diff] [blame]15224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15225 "Tx Complete Indication is received after timeout ");
15226 }
15227 break;
15228 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]15229 case WDI_P2P_NOA_START_IND :
15230 {
15231 tSirP2PNoaStart *pP2pNoaStart =
15232 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
15233
15234 if (NULL == pP2pNoaStart)
15235 {
15236 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15237 "Memory allocation failure, "
15238 "WDI_P2P_NOA_START_IND not forwarded");
15239 break;
15240 }
15241 pP2pNoaStart->status =
15242 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
15243 pP2pNoaStart->bssIdx =
15244 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
15245 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
15246 (void *)pP2pNoaStart , 0) ;
15247 break;
15248 }
15249
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]15250#ifdef FEATURE_WLAN_TDLS
15251 case WDI_TDLS_IND :
15252 {
15253 tSirTdlsInd *pTdlsInd =
15254 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
15255
15256 if (NULL == pTdlsInd)
15257 {
15258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15259 "Memory allocation failure, "
15260 "WDI_TDLS_IND not forwarded");
15261 break;
15262 }
15263 pTdlsInd->status =
15264 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
15265 pTdlsInd->assocId =
15266 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
15267 pTdlsInd->staIdx =
15268 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
15269 pTdlsInd->reasonCode =
15270 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
15271 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
15272 (void *)pTdlsInd , 0) ;
15273 break;
15274 }
15275#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15276 case WDI_P2P_NOA_ATTR_IND :
15277 {
15278 tSirP2PNoaAttr *pP2pNoaAttr =
15279 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15281 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15282 if (NULL == pP2pNoaAttr)
15283 {
15284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15285 "Memory allocation failure, "
15286 "WDI_P2P_NOA_ATTR_IND not forwarded");
15287 break;
15288 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15289 pP2pNoaAttr->index =
15290 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
15291 pP2pNoaAttr->oppPsFlag =
15292 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
15293 pP2pNoaAttr->ctWin =
15294 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
15295
15296 pP2pNoaAttr->uNoa1IntervalCnt =
15297 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
15298 pP2pNoaAttr->uNoa1Duration =
15299 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
15300 pP2pNoaAttr->uNoa1Interval =
15301 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
15302 pP2pNoaAttr->uNoa1StartTime =
15303 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15304 pP2pNoaAttr->uNoa2IntervalCnt =
15305 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
15306 pP2pNoaAttr->uNoa2Duration =
15307 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
15308 pP2pNoaAttr->uNoa2Interval =
15309 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
15310 pP2pNoaAttr->uNoa2StartTime =
15311 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15312 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
15313 (void *)pP2pNoaAttr , 0) ;
15314 break;
15315 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15316#ifdef FEATURE_WLAN_SCAN_PNO
15317 case WDI_PREF_NETWORK_FOUND_IND:
15318 {
15319 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15320 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
15321 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
15322 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
15323 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
15324
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15326 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15327 if (NULL == pPrefNetworkFoundInd)
15328 {
15329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15330 "Memory allocation failure, "
15331 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]15332 if (NULL !=
15333 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
15334 {
15335 wpalMemoryFree(
15336 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
15337 );
15338 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
15339 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15340 break;
15341 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15342 /* Message Header */
15343 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15344 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15345
15346 /* Info from WDI Indication */
15347 pPrefNetworkFoundInd->ssId.length =
15348 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15349 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15350 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
15351 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
15352 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15353 if (NULL !=
15354 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
15355 {
15356 pPrefNetworkFoundInd->frameLength =
15357 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
15358 vos_mem_copy( pPrefNetworkFoundInd->data,
15359 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
15360 pPrefNetworkFoundInd->frameLength);
15361 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
15362 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
15363 }
15364 else
15365 {
15366 pPrefNetworkFoundInd->frameLength = 0;
15367 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15368 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15369 /* VOS message wrapper */
15370 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
15371 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
15372 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15373 /* Send message to SME */
15374 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15375 {
15376 /* free the mem and return */
15377 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
15378 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15379 break;
15380 }
15381#endif // FEATURE_WLAN_SCAN_PNO
15382
15383#ifdef WLAN_WAKEUP_EVENTS
15384 case WDI_WAKE_REASON_IND:
15385 {
15386 vos_msg_t vosMsg;
15387 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
15388 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
15389 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
15390
15391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Sushant Kaushik1b645382014-10-13 16:39:36 +0530[diff] [blame]15392 "[WAKE_REASON WDI] WAKE_REASON_IND Type (%d) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15393 wdiLowLevelInd->wdiIndicationType,
15394 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
15395 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
15396 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
15397
15398 if (NULL == pWakeReasonInd)
15399 {
15400 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15401 "Memory allocation failure, "
15402 "WDI_WAKE_REASON_IND not forwarded");
15403 break;
15404 }
15405
15406 vos_mem_zero(pWakeReasonInd, allocSize);
15407
15408 /* Message Header */
15409 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
15410 pWakeReasonInd->mesgLen = allocSize;
15411
15412 /* Info from WDI Indication */
15413 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
15414 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
15415 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
15416 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
15417 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
15418 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
15419 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
15420 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
15421
15422 /* VOS message wrapper */
15423 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
15424 vosMsg.bodyptr = (void *) pWakeReasonInd;
15425 vosMsg.bodyval = 0;
15426
15427 /* Send message to SME */
15428 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15429 {
15430 /* free the mem and return */
15431 vos_mem_free((v_VOID_t *) pWakeReasonInd);
15432 }
15433
15434 break;
15435 }
15436#endif // WLAN_WAKEUP_EVENTS
15437
15438 case WDI_TX_PER_HIT_IND:
15439 {
15440 vos_msg_t vosMsg;
15441 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
15442 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
15443 /* VOS message wrapper */
15444 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
15445 vosMsg.bodyptr = NULL;
15446 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15447 /* Send message to SME */
15448 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15449 {
15450 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
15451 }
15452 break;
15453 }
15454
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15455#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15456 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15457 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15458 vos_msg_t vosMsg;
15459 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15460
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15461 lphbInd =
15462 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
15463 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15464 {
15465 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15466 "%s: LPHB IND buffer alloc Fail", __func__);
15467 return ;
15468 }
15469
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15470 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15471 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15472 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15473 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15474 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15475 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
15476
15477 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15478 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15479 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
15480
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15481 vosMsg.type = eWNI_SME_LPHB_IND;
15482 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15483 vosMsg.bodyval = 0;
15484 /* Send message to SME */
15485 if (VOS_STATUS_SUCCESS !=
15486 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15487 {
15488 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
15489 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15490 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15491 }
15492 break;
15493 }
15494#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]15495 case WDI_PERIODIC_TX_PTRN_FW_IND:
15496 {
15497 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15498 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
15499 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
15500 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
15501 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
15502 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
15503 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
15504
15505 break;
15506 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15507
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]15508 case WDI_IBSS_PEER_INACTIVITY_IND:
15509 {
15510 tSirIbssPeerInactivityInd *pIbssInd =
15511 (tSirIbssPeerInactivityInd *)
15512 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
15513
15514 if (NULL == pIbssInd)
15515 {
15516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15517 "Memory allocation failure, "
15518 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
15519 break;
15520 }
15521
15522 pIbssInd->bssIdx =
15523 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
15524 pIbssInd->staIdx =
15525 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
15526 vos_mem_copy(pIbssInd->peerAddr,
15527 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
15528 sizeof(tSirMacAddr));
15529 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
15530 break;
15531 }
15532
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15533#ifdef FEATURE_WLAN_BATCH_SCAN
15534 case WDI_BATCH_SCAN_RESULT_IND:
15535 {
15536 void *pBatchScanResult;
15537 void *pCallbackContext;
15538 tpAniSirGlobal pMac;
15539
15540 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
15541 "Received WDI_BATCHSCAN_RESULT_IND from FW");
15542
15543 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15544 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15545 {
15546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15547 "%s:pWDA is NULL", __func__);
15548 VOS_ASSERT(0);
15549 return;
15550 }
15551
15552 pBatchScanResult =
15553 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
15554 if (NULL == pBatchScanResult)
15555 {
15556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15557 "%s:Batch scan result from FW is null can't invoke HDD callback",
15558 __func__);
15559 VOS_ASSERT(0);
15560 return;
15561 }
15562
15563 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
15564 if (NULL == pMac)
15565 {
15566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15567 "%s:pMac is NULL", __func__);
15568 VOS_ASSERT(0);
15569 return;
15570 }
15571
15572 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
15573 /*call hdd callback with set batch scan response data*/
15574 if(pMac->pmc.batchScanResultCallback)
15575 {
15576 pMac->pmc.batchScanResultCallback(pCallbackContext,
15577 pBatchScanResult);
15578 }
15579 else
15580 {
15581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15582 "%s:HDD callback is null", __func__);
15583 VOS_ASSERT(0);
15584 }
15585 break;
15586 }
15587#endif
15588
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]15589#ifdef FEATURE_WLAN_CH_AVOID
15590 case WDI_CH_AVOID_IND:
15591 {
15592 vos_msg_t vosMsg;
15593 tSirChAvoidIndType *chAvoidInd;
15594
15595 chAvoidInd =
15596 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
15597 if (NULL == chAvoidInd)
15598 {
15599 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15600 "%s: CH_AVOID IND buffer alloc Fail", __func__);
15601 return ;
15602 }
15603
15604 chAvoidInd->avoidRangeCount =
15605 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
15606 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
15607 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
15608 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
15609
15610 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15611 "%s : WDA CH avoid notification", __func__);
15612
15613 vosMsg.type = eWNI_SME_CH_AVOID_IND;
15614 vosMsg.bodyptr = chAvoidInd;
15615 vosMsg.bodyval = 0;
15616 /* Send message to SME */
15617 if (VOS_STATUS_SUCCESS !=
15618 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15619 {
15620 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15621 "post eWNI_SME_CH_AVOID_IND to SME Failed");
15622 vos_mem_free(chAvoidInd);
15623 }
15624 break;
15625 }
15626#endif /* FEATURE_WLAN_CH_AVOID */
15627
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15628#ifdef WLAN_FEATURE_LINK_LAYER_STATS
15629 case WDI_LL_STATS_RESULTS_IND:
15630 {
15631 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15632 tpAniSirGlobal pMac;
15633
15634 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15635 "Received WDI_LL_STATS_RESULTS_IND from FW");
15636
15637 /*sanity check*/
15638 if (NULL == pWDA)
15639 {
15640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15641 "%s:pWDA is NULL", __func__);
15642 VOS_ASSERT(0);
15643 return;
15644 }
15645
15646 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]15647 (void *)wdiLowLevelInd->
15648 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15649 if (NULL == pLinkLayerStatsInd)
15650 {
15651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15652 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
15653 __func__);
15654 VOS_ASSERT(0);
15655 return;
15656 }
15657
15658 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
15659 if (NULL == pMac)
15660 {
15661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15662 "%s:pMac is NULL", __func__);
15663 VOS_ASSERT(0);
15664 return;
15665 }
15666
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]15667 /* call hdd callback with Link Layer Statistics.
15668 * vdev_id/ifacId in link_stats_results will be
15669 * used to retrieve the correct HDD context
15670 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15671 if (pMac->sme.pLinkLayerStatsIndCallback)
15672 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]15673 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15674 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]15675 pLinkLayerStatsInd,
15676 wdiLowLevelInd->
15677 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15678 }
15679 else
15680 {
15681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15682 "%s:HDD callback is null", __func__);
15683 }
15684 break;
15685 }
15686#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
15687
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]15688#ifdef WLAN_FEATURE_EXTSCAN
15689 case WDI_EXTSCAN_PROGRESS_IND:
15690 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
15691 case WDI_EXTSCAN_SCAN_RESULT_IND:
15692 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]15693 case WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND:
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]15694 {
15695 void *pEXTScanData;
15696 void *pCallbackContext;
15697 tpAniSirGlobal pMac;
15698 tANI_U16 indType;
15699
15700 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15701 "Received WDI_EXTSCAN Indications from FW");
15702 /*sanity check*/
15703 if (NULL == pWDA)
15704 {
15705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15706 "%s:pWDA is NULL", __func__);
15707 VOS_ASSERT(0);
15708 return;
15709 }
15710 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
15711 {
15712 indType = WDA_EXTSCAN_PROGRESS_IND;
15713
15714 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15715 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
15716 }
15717 if (wdiLowLevelInd->wdiIndicationType ==
15718 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
15719 {
15720 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
15721
15722 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15723 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
15724 }
15725 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
15726 {
15727 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
15728
15729 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15730 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
15731 }
15732 if (wdiLowLevelInd->wdiIndicationType ==
15733 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
15734 {
15735 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
15736
15737 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15738 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
15739 }
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]15740 if (wdiLowLevelInd->wdiIndicationType ==
15741 WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND)
15742 {
15743 indType = WDA_EXTSCAN_SSID_HOTLIST_RESULT_IND;
15744
15745 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15746 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND");
15747 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]15748
15749 pEXTScanData =
15750 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
15751 if (NULL == pEXTScanData)
15752 {
15753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15754 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
15755 __func__);
15756 VOS_ASSERT(0);
15757 return;
15758 }
15759
15760 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
15761 if (NULL == pMac)
15762 {
15763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15764 "%s:pMac is NULL", __func__);
15765 VOS_ASSERT(0);
15766 return;
15767 }
15768
15769 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
15770
15771 if(pMac->sme.pEXTScanIndCb)
15772 {
15773 pMac->sme.pEXTScanIndCb(pCallbackContext,
15774 indType,
15775 pEXTScanData);
15776 }
15777 else
15778 {
15779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15780 "%s:HDD callback is null", __func__);
15781 }
15782 break;
15783 }
15784#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]15785 case WDI_DEL_BA_IND:
15786 {
15787 tpBADeleteParams pDelBAInd =
15788 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
15789
15790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15791 "Received WDI_DEL_BA_IND from WDI ");
15792 if(NULL == pDelBAInd)
15793 {
15794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15795 "%s: VOS MEM Alloc Failure", __func__);
15796 break;
15797 }
15798 vos_mem_copy(pDelBAInd->peerMacAddr,
15799 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
15800 sizeof(tSirMacAddr));
15801 vos_mem_copy(pDelBAInd->bssId,
15802 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
15803 sizeof(tSirMacAddr));
15804 pDelBAInd->staIdx =
15805 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
15806 pDelBAInd->baTID =
15807 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
15808 pDelBAInd->baDirection =
15809 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
15810 pDelBAInd->reasonCode =
15811 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
15812
15813 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
15814 (void *)pDelBAInd , 0) ;
15815 break;
15816 }
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]15817 case WDI_NAN_EVENT_IND:
15818 {
15819 vos_msg_t vosMsg;
15820 tpSirNanEvent pSirNanEvent = NULL;
15821
15822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15823 "Received WDI_NAN_EVENT");
15824
15825 pSirNanEvent = (tpSirNanEvent)vos_mem_malloc( sizeof( tSirNanEvent )
15826 - sizeof( pSirNanEvent->event_data)
15827 + wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len);
15828
15829 if (NULL == pSirNanEvent)
15830 {
15831 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15832 "%s: VOS MEM Alloc Failure", __func__);
15833 VOS_ASSERT(0) ;
15834 break;
15835 }
15836
15837 pSirNanEvent->event_data_len =
15838 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len;
15839
15840 if (wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len)
15841 {
15842 vos_mem_copy( pSirNanEvent->event_data,
15843 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data,
15844 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len);
15845 }
15846
15847 /* VOS message wrapper */
15848 vosMsg.type = eWNI_SME_NAN_EVENT;
15849 vosMsg.bodyptr = pSirNanEvent;
15850 vosMsg.bodyval = 0;
15851
15852 /* Send message to SME */
15853 if (VOS_STATUS_SUCCESS
15854 != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15855 {
15856 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
15857 "post eWNI_SME_NAN_EVENT to SME Failed");
15858 vos_mem_free(pSirNanEvent);
15859 }
15860 break;
15861 }
Sachin Ahuja3d47fcd2015-08-28 16:02:06 +0530[diff] [blame]15862 case WDI_LOST_LINK_PARAMS_IND:
15863 {
15864 tpSirSmeLostLinkParamsInd pLostLinkParamInd =
15865 (tpSirSmeLostLinkParamsInd)vos_mem_malloc(sizeof(tSirSmeLostLinkParamsInd));
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]15866
Sachin Ahuja3d47fcd2015-08-28 16:02:06 +0530[diff] [blame]15867 if (NULL == pLostLinkParamInd)
15868 {
15869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15870 "%s: VOS MEM Alloc Failure", __func__);
15871 break;
15872 }
15873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15874 "Received WDI_LOST_LINK_PARAMS_IND from WDI ");
15875
15876 pLostLinkParamInd->messageType = eWNI_SME_LOST_LINK_PARAMS_IND;
15877 pLostLinkParamInd->length = sizeof(tSirSmeMicFailureInd);
15878 pLostLinkParamInd->info.bssIdx =
15879 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.bssIdx;
15880 pLostLinkParamInd->info.rssi =
15881 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rssi;
15882 vos_mem_copy(pLostLinkParamInd->info.selfMacAddr,
15883 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.selfMacAddr,
15884 sizeof(tSirMacAddr));
15885 pLostLinkParamInd->info.linkFlCnt =
15886 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.linkFlCnt;
15887 pLostLinkParamInd->info.linkFlTx =
15888 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.linkFlTx;
15889 pLostLinkParamInd->info.lastDataRate =
15890 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.lastDataRate;
15891 pLostLinkParamInd->info.rsvd1 =
15892 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rsvd1;
15893 pLostLinkParamInd->info.rsvd2 =
15894 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rsvd2;
15895 WDA_SendMsg(pWDA, SIR_HAL_LOST_LINK_PARAMS_IND,
15896 (void *)pLostLinkParamInd , 0) ;
15897 break;
15898 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15899 default:
15900 {
15901 /* TODO error */
15902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15903 "Received UNKNOWN Indication from WDI ");
15904 }
15905 }
15906 return ;
15907}
15908
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15909/*
15910 * BA related processing in WDA.
15911 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15912void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
15913 void* pUserData)
15914{
15915 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15916 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15917 if(NULL == pWdaParams)
15918 {
15919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15920 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15921 VOS_ASSERT(0) ;
15922 return ;
15923 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15924 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15925 vos_mem_free(pWdaParams->wdaMsgParam) ;
15926 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15927 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15929 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15930 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
15931 {
15932 tANI_U8 i = 0 ;
15933 tBaActivityInd *baActivityInd = NULL ;
15934 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
15935 tANI_U8 allocSize = sizeof(tBaActivityInd)
15936 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
15937 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
15938 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15939 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15940 if(NULL == baActivityInd)
15941 {
15942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15943 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15944 VOS_ASSERT(0) ;
15945 return;
15946 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15947 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
15948 sizeof(tSirMacAddr)) ;
15949 baActivityInd->baCandidateCnt = baCandidateCount ;
15950
15951 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
15952 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
15953
15954 for(i = 0 ; i < baCandidateCount ; i++)
15955 {
15956 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15957 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
15958 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15959 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
15960 {
15961 baCandidate->baInfo[tid].fBaEnable =
15962 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
15963 baCandidate->baInfo[tid].startingSeqNum =
15964 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
15965 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]15966 wdiBaCandidate++ ;
15967 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15968 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15969 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
15970 }
15971 else
15972 {
15973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15974 "BA Trigger RSP with Failure received ");
15975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15976 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15977}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]15978
15979
15980/*
15981 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
15982 * during MCC
15983 */
15984void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
15985{
15986 wpt_uint32 enabled;
15987 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
15988 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
15989 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
15990
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15991 if (NULL == pMac )
15992 {
15993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15994 "%s: Invoked with invalid MAC context ", __func__ );
15995 VOS_ASSERT(0);
15996 return;
15997 }
15998
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]15999 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
16000 != eSIR_SUCCESS)
16001 {
16002 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16003 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
16004 return;
16005 }
16006
16007 if(!enabled)
16008 {
16009 return;
16010 }
16011
16012 if(NULL == pWDA)
16013 {
16014 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16015 "%s:WDA context is NULL", __func__);
16016 VOS_ASSERT(0);
16017 return;
16018 }
16019
16020 if(activate)
16021 {
16022 if( VOS_STATUS_SUCCESS !=
16023 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16024 {
16025 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16026 "Traffic Stats Timer Start Failed ");
16027 return;
16028 }
16029 WDI_DS_ActivateTrafficStats();
16030 }
16031 else
16032 {
16033 WDI_DS_DeactivateTrafficStats();
16034 WDI_DS_ClearTrafficStats();
16035
16036 if( VOS_STATUS_SUCCESS !=
16037 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16038 {
16039 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16040 "Traffic Stats Timer Stop Failed ");
16041 return;
16042 }
16043 }
16044}
16045
16046/*
16047 * Traffic Stats Timer handler
16048 */
16049void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
16050{
16051 WDI_Status wdiStatus;
16052 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
16053 WDI_TrafficStatsIndType trafficStatsIndParams;
16054 wpt_uint32 length, enabled;
16055 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16056
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16057 if (NULL == pMac )
16058 {
16059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16060 "%s: Invoked with invalid MAC context ", __func__ );
16061 VOS_ASSERT(0);
16062 return;
16063 }
16064
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16065 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
16066 != eSIR_SUCCESS)
16067 {
16068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16069 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
16070 return;
16071 }
16072
16073 if(!enabled)
16074 {
16075 WDI_DS_DeactivateTrafficStats();
16076 return;
16077 }
16078
16079 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
16080
16081 if(pWdiTrafficStats != NULL)
16082 {
16083 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
16084 trafficStatsIndParams.length = length;
16085 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]16086 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16087 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
16088 trafficStatsIndParams.pUserData = pWDA;
16089
16090 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
16091
16092 if(WDI_STATUS_PENDING == wdiStatus)
16093 {
16094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16095 "Pending received for %s:%d ",__func__,__LINE__ );
16096 }
16097 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
16098 {
16099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16100 "Failure in %s:%d ",__func__,__LINE__ );
16101 }
16102
16103 WDI_DS_ClearTrafficStats();
16104 }
16105 else
16106 {
16107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
16108 "pWdiTrafficStats is Null");
16109 }
16110
16111 if( VOS_STATUS_SUCCESS !=
16112 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16113 {
16114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
16115 "Traffic Stats Timer Start Failed ");
16116 return;
16117 }
16118}
16119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16120/*
16121 * BA Activity check timer handler
16122 */
16123void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
16124{
16125 tANI_U8 curSta = 0 ;
16126 tANI_U8 tid = 0 ;
16127 tANI_U8 size = 0 ;
16128 tANI_U8 baCandidateCount = 0 ;
16129 tANI_U8 newBaCandidate = 0 ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16130 tANI_U32 val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16131 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16132 tpAniSirGlobal pMac;
16133
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]16134 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16135 {
16136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]16137 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16138 VOS_ASSERT(0);
16139 return ;
16140 }
16141 if(WDA_MAX_STA < pWDA->wdaMaxSta)
16142 {
16143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16144 "Inconsistent STA entries in WDA");
16145 VOS_ASSERT(0) ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16146 }
16147 if(NULL == pWDA->pVosContext)
16148 {
16149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16150 "%s: pVosContext is NULL",__func__);
16151 VOS_ASSERT(0);
16152 return ;
16153 }
16154 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Abhishek Singh68883952014-10-14 11:59:05 +0530[diff] [blame]16155 if(NULL == pMac)
16156 {
16157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16158 "%s: pMac is NULL",__func__);
16159 VOS_ASSERT(0);
16160 return ;
16161 }
16162
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16163 if (wlan_cfgGetInt(pMac,
16164 WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC, &val) !=
16165 eSIR_SUCCESS)
16166 {
16167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16168 "Unable to get WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC");
16169 val = 0;
16170 }
16171
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16172 /* walk through all STA entries and find out TX packet count */
16173 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
16174 {
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16175 tANI_U32 currentOperChan = pWDA->wdaStaInfo[curSta].currentOperChan;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]16176#ifdef WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16177 // We can only do BA on "hard" STAs.
16178 if (!(IS_HWSTA_IDX(curSta)))
16179 {
16180 continue;
16181 }
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]16182#endif //WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16183 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
16184 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16185 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16186 tANI_U32 txPktCount = 0 ;
16187 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16188 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16189 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
16190 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16191 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
16192 curSta, tid, &txPktCount)))
16193 {
16194#if 0
16195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
16196 "************* %d:%d, %d ",curSta, txPktCount,
16197 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
16198#endif
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16199 if(val && ( (currentOperChan >= SIR_11B_CHANNEL_BEGIN) &&
16200 (currentOperChan <= SIR_11B_CHANNEL_END)))
16201 {
16202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16203 "%s: BTC disabled aggregation - dont start "
16204 "TX ADDBA req",__func__);
16205 }
16206 else if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16207 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Abhishek Singh424ae432014-12-05 11:54:54 +0530[diff] [blame]16208 && (((eSYSTEM_STA_IN_IBSS_ROLE ==
16209 pWDA->wdaGlobalSystemRole) && txPktCount )
16210 || (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
16211 curSta, tid))))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16212 {
16213 /* get prepare for sending message to HAL */
16214 //baCandidate[baCandidateCount].staIdx = curSta ;
16215 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
16216 newBaCandidate = WDA_ENABLE_BA ;
16217 }
16218 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
16219 }
16220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16221 /* fill the entry for all the sta with given TID's */
16222 if(WDA_ENABLE_BA == newBaCandidate)
16223 {
16224 /* move to next BA candidate */
16225 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
16226 size += sizeof(WDI_TriggerBAReqCandidateType) ;
16227 baCandidateCount++ ;
16228 newBaCandidate = WDA_DISABLE_BA ;
16229 }
16230 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16231 /* prepare and send message to hal */
16232 if( 0 < baCandidateCount)
16233 {
16234 WDI_Status status = WDI_STATUS_SUCCESS ;
16235 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
16236 tWDA_ReqParams *pWdaParams =
16237 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16238 if(NULL == pWdaParams)
16239 {
16240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16241 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16242 VOS_ASSERT(0) ;
16243 return;
16244 }
16245 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
16246 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
16247 if(NULL == wdiTriggerBaReq)
16248 {
16249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16250 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16251 VOS_ASSERT(0) ;
16252 vos_mem_free(pWdaParams);
16253 return;
16254 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16255 do
16256 {
16257 WDI_TriggerBAReqinfoType *triggerBaInfo =
16258 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
16259 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
16260 /* TEMP_FIX: Need to see if WDI need check for assoc session for
16261 * for each request */
16262 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
16263 triggerBaInfo->ucBASessionID = 0;
16264 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
16265 } while(0) ;
16266 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
16267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16268 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16269 pWdaParams->pWdaContext = pWDA;
16270 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
16271 pWdaParams->wdaMsgParam = NULL;
16272 status = WDI_TriggerBAReq(wdiTriggerBaReq,
16273 WDA_TriggerBaReqCallback, pWdaParams) ;
16274 if(IS_WDI_STATUS_FAILURE(status))
16275 {
16276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16277 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
16278 vos_mem_free(pWdaParams->wdaMsgParam) ;
16279 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16280 vos_mem_free(pWdaParams) ;
16281 }
16282 }
16283 else
16284 {
16285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
16286 "There is no TID for initiating BA");
16287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16288 if( VOS_STATUS_SUCCESS !=
16289 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
16290 {
16291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16292 "BA Activity Timer Stop Failed ");
16293 return ;
16294 }
16295 if( VOS_STATUS_SUCCESS !=
16296 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
16297 {
16298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16299 "BA Activity Timer Start Failed ");
16300 return;
16301 }
16302 return ;
16303}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16304/*
16305 * WDA common routine to create timer used by WDA.
16306 */
16307static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
16308{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16309 VOS_STATUS status = VOS_STATUS_SUCCESS ;
16310 tANI_U32 val = 0 ;
16311 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16312
16313 if(NULL == pMac)
16314 {
16315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16316 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16317 VOS_ASSERT(0);
16318 return VOS_STATUS_E_FAILURE;
16319 }
16320 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
16321 != eSIR_SUCCESS)
16322 {
16323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16324 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
16325 return VOS_STATUS_E_FAILURE;
16326 }
16327 val = SYS_MS_TO_TICKS(val) ;
16328
16329 /* BA activity check timer */
16330 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
16331 "BA Activity Check timer", WDA_TimerHandler,
16332 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
16333 if(status != TX_SUCCESS)
16334 {
16335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16336 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16337 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16338 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16339 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16340 /* Tx Complete Timeout timer */
16341 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
16342 "Tx Complete Check timer", WDA_TimerHandler,
16343 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16344 if(status != TX_SUCCESS)
16345 {
16346 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16347 "Unable to create Tx Complete Timeout timer");
16348 /* Destroy timer of BA activity check timer */
16349 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16350 if(status != TX_SUCCESS)
16351 {
16352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16353 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16354 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16355 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16356 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16357 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16358
16359 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
16360
16361 /* Traffic Stats timer */
16362 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
16363 "Traffic Stats timer", WDA_TimerHandler,
16364 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
16365 if(status != TX_SUCCESS)
16366 {
16367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16368 "Unable to create traffic stats timer");
16369 /* Destroy timer of BA activity check timer */
16370 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16371 if(status != TX_SUCCESS)
16372 {
16373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16374 "Unable to Destroy BA activity timer");
16375 }
16376 /* Destroy timer of tx complete timer */
16377 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
16378 if(status != TX_SUCCESS)
16379 {
16380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16381 "Unable to Tx complete timer");
16382 }
16383 return VOS_STATUS_E_FAILURE ;
16384 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16385 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16386}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16387/*
16388 * WDA common routine to destroy timer used by WDA.
16389 */
16390static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
16391{
16392 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16393 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
16394 if(status != TX_SUCCESS)
16395 {
16396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16397 "Unable to Destroy Tx Complete Timeout timer");
16398 return eSIR_FAILURE ;
16399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16400 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16401 if(status != TX_SUCCESS)
16402 {
16403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16404 "Unable to Destroy BA activity timer");
16405 return eSIR_FAILURE ;
16406 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16407 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
16408 if(status != TX_SUCCESS)
16409 {
16410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16411 "Unable to Destroy traffic stats timer");
16412 return eSIR_FAILURE ;
16413 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16414 return eSIR_SUCCESS ;
16415}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16416/*
16417 * WDA timer handler.
16418 */
16419void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
16420{
16421 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
16422 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16423 /*
16424 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
16425 */
16426 wdaMsg.type = timerInfo ;
16427 wdaMsg.bodyptr = NULL;
16428 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16429 /* post the message.. */
16430 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
16431 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
16432 {
16433 vosStatus = VOS_STATUS_E_BADMSG;
16434 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16435}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16436/*
16437 * WDA Tx Complete timeout Indication.
16438 */
16439void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
16440{
16441 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]16442 tpSirTxBdStatus txBdStatus = {0};
16443
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16444 if( pWDA->pAckTxCbFunc )
16445 {
16446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16447 "TxComplete timer expired");
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]16448 /*Indicate failure*/
16449 pWDA->pAckTxCbFunc( pMac, &txBdStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16450 pWDA->pAckTxCbFunc = NULL;
16451 }
16452 else
16453 {
16454 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16455 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16456 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16457}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16458/*
16459 * WDA Set REG Domain to VOS NV
16460 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]16461eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
16462 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16463{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]16464 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16465 {
16466 return eHAL_STATUS_INVALID_PARAMETER;
16467 }
16468 return eHAL_STATUS_SUCCESS;
16469}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16470
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16471#ifdef FEATURE_WLAN_SCAN_PNO
16472/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16473 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16474 *
16475 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16476void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16477{
16478 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16479 tSirPNOScanReq *pPNOScanReqParams;
16480
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16482 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16483 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16484 {
16485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16486 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16487 VOS_ASSERT(0) ;
16488 return ;
16489 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16490
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16491 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
16492 if(pPNOScanReqParams->statusCallback)
16493 {
16494 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
16495 (status == WDI_STATUS_SUCCESS) ?
16496 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
16497 }
16498
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]16499 if (pPNOScanReqParams->enable == 1)
16500 {
16501 if (pPNOScanReqParams->aNetworks)
16502 vos_mem_free(pPNOScanReqParams->aNetworks);
16503 if (pPNOScanReqParams->p24GProbeTemplate)
16504 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
16505 if (pPNOScanReqParams->p5GProbeTemplate)
16506 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
16507 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16508 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16509 vos_mem_free(pWdaParams->wdaMsgParam);
16510 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16511
16512 return ;
16513}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16514/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16515 * FUNCTION: WDA_PNOScanReqCallback
16516 * Free memory.
16517 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
16518 */
16519void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16520{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16521 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16522 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16523
16524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16525 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
16526
16527 if(NULL == pWdaParams)
16528 {
16529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16530 "%s: pWdaParams received NULL", __func__);
16531 VOS_ASSERT(0);
16532 return;
16533 }
16534
16535 if(IS_WDI_STATUS_FAILURE(wdiStatus))
16536 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16537 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
16538 if(pPNOScanReqParams->statusCallback)
16539 {
16540 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
16541 VOS_STATUS_E_FAILURE);
16542 }
16543
Hanumantha Reddy Pothula06e87b22015-03-02 18:02:23 +0530[diff] [blame]16544 if (pPNOScanReqParams->enable == 1)
16545 {
16546 if (pPNOScanReqParams->aNetworks)
16547 vos_mem_free(pPNOScanReqParams->aNetworks);
16548 if (pPNOScanReqParams->p24GProbeTemplate)
16549 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
16550 if (pPNOScanReqParams->p5GProbeTemplate)
16551 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
16552 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16553 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16554 vos_mem_free(pWdaParams->wdaMsgParam);
16555 vos_mem_free(pWdaParams);
16556 }
16557
16558 return;
16559}
16560/*
16561 * FUNCTION: WDA_UpdateScanParamsRespCallback
16562 *
16563 */
16564void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
16565{
16566 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16568 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16569 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16570 {
16571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16572 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16573 VOS_ASSERT(0) ;
16574 return ;
16575 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16576
16577 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16578 vos_mem_free(pWdaParams->wdaMsgParam);
16579 vos_mem_free(pWdaParams);
16580
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16581 return ;
16582}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16583/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16584 * FUNCTION: WDA_UpdateScanParamsReqCallback
16585 * Free memory.
16586 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
16587 */
16588void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
16589{
16590 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16591
16592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16593 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
16594
16595 if(NULL == pWdaParams)
16596 {
16597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16598 "%s: pWdaParams received NULL", __func__);
16599 VOS_ASSERT(0);
16600 return;
16601 }
16602
16603 if(IS_WDI_STATUS_FAILURE(wdiStatus))
16604 {
16605 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16606 vos_mem_free(pWdaParams->wdaMsgParam);
16607 vos_mem_free(pWdaParams);
16608 }
16609
16610 return;
16611}
16612/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16613 * FUNCTION: WDA_ProcessSetPreferredNetworkList
16614 * Request to WDI to set Preferred Network List.Offload
16615 */
16616VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
16617 tSirPNOScanReq *pPNOScanReqParams)
16618{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]16619 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16620 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
16621 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
16622 tWDA_ReqParams *pWdaParams ;
16623 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16625 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16626 if(NULL == pwdiPNOScanReqInfo)
16627 {
16628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16629 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16630 VOS_ASSERT(0);
16631 return VOS_STATUS_E_NOMEM;
16632 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16633 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16634 if(NULL == pWdaParams)
16635 {
16636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16637 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16638 VOS_ASSERT(0);
16639 vos_mem_free(pwdiPNOScanReqInfo);
16640 return VOS_STATUS_E_NOMEM;
16641 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16642 //
16643 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
16644 //
16645 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
16646 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16647 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
16648 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
16649 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16650 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
16651 {
16652 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
16653 &pPNOScanReqParams->aNetworks[i],
16654 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
16655 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16656 /*Scan timer intervals*/
16657 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
16658 &pPNOScanReqParams->scanTimers,
16659 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16660 /*Probe template for 2.4GHz band*/
16661 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
16662 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
16663 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16664 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
16665 pPNOScanReqParams->p24GProbeTemplate,
16666 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16667 /*Probe template for 5GHz band*/
16668 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
16669 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
16670 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16671 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
16672 pPNOScanReqParams->p5GProbeTemplate,
16673 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16674 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
16675 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16676
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16677 /* Store Params pass it to WDI */
16678 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
16679 pWdaParams->pWdaContext = pWDA;
16680 /* Store param pointer as passed in by caller */
16681 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16682 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16683 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16684 if(IS_WDI_STATUS_FAILURE(status))
16685 {
16686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16687 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16688 if(pPNOScanReqParams->statusCallback)
16689 {
16690 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
16691 VOS_STATUS_E_FAILURE);
16692 }
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]16693 if (pPNOScanReqParams->enable == 1)
16694 {
16695 if (pPNOScanReqParams->aNetworks)
16696 vos_mem_free(pPNOScanReqParams->aNetworks);
16697 if (pPNOScanReqParams->p24GProbeTemplate)
16698 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
16699 if (pPNOScanReqParams->p5GProbeTemplate)
16700 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
16701 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16702 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16703 vos_mem_free(pWdaParams->wdaMsgParam);
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]16704
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16705 pWdaParams->wdaWdiApiMsgParam = NULL;
16706 pWdaParams->wdaMsgParam = NULL;
16707 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16708 return CONVERT_WDI2VOS_STATUS(status) ;
16709}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16710
16711#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
16712
16713void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
16714{
16715 /*Convert the CSR Auth types to WDI Auth types */
16716 switch (csrAuthType)
16717 {
16718 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
16719 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
16720 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]16721#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16722 case eCSR_AUTH_TYPE_CCKM_WPA:
16723 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
16724 break;
16725#endif
16726 case eCSR_AUTH_TYPE_WPA:
16727 *AuthType = eWDA_AUTH_TYPE_WPA;
16728 break;
16729 case eCSR_AUTH_TYPE_WPA_PSK:
16730 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
16731 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]16732#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16733 case eCSR_AUTH_TYPE_CCKM_RSN:
16734 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
16735 break;
16736#endif
16737 case eCSR_AUTH_TYPE_RSN:
16738 *AuthType = eWDA_AUTH_TYPE_RSN;
16739 break;
16740 case eCSR_AUTH_TYPE_RSN_PSK:
16741 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
16742 break;
16743#if defined WLAN_FEATURE_VOWIFI_11R
16744 case eCSR_AUTH_TYPE_FT_RSN:
16745 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
16746 break;
16747 case eCSR_AUTH_TYPE_FT_RSN_PSK:
16748 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
16749 break;
16750#endif
16751#ifdef FEATURE_WLAN_WAPI
16752 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
16753 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
16754 break;
16755 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
16756 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
16757 break;
16758#endif /* FEATURE_WLAN_WAPI */
16759 case eCSR_AUTH_TYPE_SHARED_KEY:
16760 case eCSR_AUTH_TYPE_AUTOSWITCH:
16761 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
16762 break;
Kanchanapally, Vidyullatha3355dd32015-06-09 14:56:56 +0530[diff] [blame]16763#ifdef WLAN_FEATURE_11W
16764 case eCSR_AUTH_TYPE_RSN_PSK_SHA256:
16765 *AuthType = eWDA_AUTH_TYPE_RSN_PSK_SHA256;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16766 break;
Kanchanapally, Vidyullatha3355dd32015-06-09 14:56:56 +0530[diff] [blame]16767 case eCSR_AUTH_TYPE_RSN_8021X_SHA256:
16768 *AuthType = eWDA_AUTH_TYPE_RSN_8021X_SHA256;
16769 break;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16770#endif
16771 default:
Deepthi Gowribfd17132014-11-14 17:59:04 +0530[diff] [blame]16772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16773 "%s: Unknown Auth Type", __func__);
16774 break;
16775 }
16776}
16777void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
16778{
16779 switch (csrEncrType)
16780 {
16781 case eCSR_ENCRYPT_TYPE_NONE:
16782 *EncrType = WDI_ED_NONE;
16783 break;
16784 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
16785 case eCSR_ENCRYPT_TYPE_WEP40:
16786 *EncrType = WDI_ED_WEP40;
16787 break;
16788 case eCSR_ENCRYPT_TYPE_WEP104:
16789 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
16790 *EncrType = WDI_ED_WEP104;
16791 break;
16792 case eCSR_ENCRYPT_TYPE_TKIP:
16793 *EncrType = WDI_ED_TKIP;
16794 break;
16795 case eCSR_ENCRYPT_TYPE_AES:
16796 *EncrType = WDI_ED_CCMP;
16797 break;
16798#ifdef WLAN_FEATURE_11W
16799 case eCSR_ENCRYPT_TYPE_AES_CMAC:
16800 *EncrType = WDI_ED_AES_128_CMAC;
16801 break;
16802#endif
16803#ifdef FEATURE_WLAN_WAPI
16804 case eCSR_ENCRYPT_TYPE_WPI:
16805 *EncrType = WDI_ED_WPI;
16806 break;
16807#endif
16808 case eCSR_ENCRYPT_TYPE_ANY:
16809 *EncrType = WDI_ED_ANY;
16810 break;
16811
16812 default:
16813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16814 "%s: Unknown Encryption Type", __func__);
16815 break;
16816 }
16817}
16818
16819/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16820 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16821 * Request to WDI to set Roam Offload Scan
16822 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16823VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16824 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
16825{
16826 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16827 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
16828 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16829 tWDA_ReqParams *pWdaParams ;
16830 v_U8_t csrAuthType;
16831 WDI_RoamNetworkType *pwdiRoamNetworkType;
16832 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
16833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16834 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16835 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16836 {
16837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16838 "%s: VOS MEM Alloc Failure", __func__);
16839 VOS_ASSERT(0);
16840 return VOS_STATUS_E_NOMEM;
16841 }
16842 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16843 if (NULL == pWdaParams)
16844 {
16845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16846 "%s: VOS MEM Alloc Failure", __func__);
16847 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16848 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16849 return VOS_STATUS_E_NOMEM;
16850 }
16851
16852 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16853 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16854 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16855 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
16856 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16857 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
16858 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
16859 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
16860 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
16861 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
16862 sizeof(pwdiRoamNetworkType->currAPbssid));
16863 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
16864 csrAuthType);
16865 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
16866 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
16867 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
16868 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
16869 pwdiRoamOffloadScanInfo->LookupThreshold =
16870 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]16871 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
16872 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16873 pwdiRoamOffloadScanInfo->RoamRssiDiff =
16874 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]16875 pwdiRoamOffloadScanInfo->MAWCEnabled =
16876 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16877 pwdiRoamOffloadScanInfo->Command =
16878 pRoamOffloadScanReqParams->Command ;
16879 pwdiRoamOffloadScanInfo->StartScanReason =
16880 pRoamOffloadScanReqParams->StartScanReason ;
16881 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
16882 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
16883 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
16884 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
16885 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
16886 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
16887 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
16888 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
16889 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
16890 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]16891 pwdiRoamOffloadScanInfo->IsESEEnabled =
16892 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16893 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
16894 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
16895 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
16896 pwdiRoamNetworkType->ssId.ucLength =
16897 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
16898 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
16899 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
16900 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
16901 pwdiRoamNetworkType->ChannelCount =
16902 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
16903 pwdiRoamOffloadScanInfo->ChannelCacheType =
16904 pRoamOffloadScanReqParams->ChannelCacheType;
16905 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
16906 pRoamOffloadScanReqParams->ValidChannelList,
16907 pRoamOffloadScanReqParams->ValidChannelCount);
16908 pwdiRoamOffloadScanInfo->ValidChannelCount =
16909 pRoamOffloadScanReqParams->ValidChannelCount;
16910 pwdiRoamOffloadScanInfo->us24GProbeSize =
16911 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
16912 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
16913 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
16914 pRoamOffloadScanReqParams->p24GProbeTemplate,
16915 pwdiRoamOffloadScanInfo->us24GProbeSize);
16916 pwdiRoamOffloadScanInfo->us5GProbeSize =
16917 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
16918 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
16919 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
16920 pRoamOffloadScanReqParams->p5GProbeTemplate,
16921 pwdiRoamOffloadScanInfo->us5GProbeSize);
16922 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
16923 pRoamOffloadScanReqParams->MDID.mdiePresent;
16924 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
16925 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16926 pwdiRoamOffloadScanInfo->nProbes =
16927 pRoamOffloadScanReqParams->nProbes;
16928 pwdiRoamOffloadScanInfo->HomeAwayTime =
16929 pRoamOffloadScanReqParams->HomeAwayTime;
16930 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16931 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16932 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16933 pWdaParams->pWdaContext = pWDA;
16934 /* Store param pointer as passed in by caller */
16935 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]16936 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]16937 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
16938 if(IS_WDI_STATUS_FAILURE(status))
16939 {
16940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16941 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
16942 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16943 vos_mem_free(pWdaParams->wdaMsgParam);
16944 pWdaParams->wdaWdiApiMsgParam = NULL;
16945 pWdaParams->wdaMsgParam = NULL;
16946 }
16947 return CONVERT_WDI2VOS_STATUS(status) ;
16948}
16949#endif
16950
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16951/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16952 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16953 *
16954 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16955void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16956{
16957 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16958
16959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16960 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16961
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16962 if(NULL == pWdaParams)
16963 {
16964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16965 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16966 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16967 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16968 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16969
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16970 vos_mem_free(pWdaParams->wdaMsgParam) ;
16971 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16972 vos_mem_free(pWdaParams) ;
16973
16974 return ;
16975}
16976/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16977 * FUNCTION: WDA_RssiFilterReqCallback
16978 * Free memory.
16979 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
16980 */
16981void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
16982{
16983 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16984
16985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16986 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
16987
16988 if(NULL == pWdaParams)
16989 {
16990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16991 "%s: pWdaParams received NULL", __func__);
16992 VOS_ASSERT(0);
16993 return;
16994 }
16995
16996 if(IS_WDI_STATUS_FAILURE(wdiStatus))
16997 {
16998 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16999 vos_mem_free(pWdaParams->wdaMsgParam);
17000 vos_mem_free(pWdaParams);
17001 }
17002
17003 return;
17004}
17005/*
Hanumantha Reddy Pothula1e687da2015-03-31 13:44:31 +0530[diff] [blame]17006 * FUNCTION: WDA_ProcessSetRssiFilterReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17007 * Request to WDI to set Preferred Network List.Offload
17008 */
17009VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
17010 tSirSetRSSIFilterReq* pRssiFilterParams)
17011{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17012 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17013 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
17014 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
17015 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17017 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17018 if(NULL == pwdiSetRssiFilterReqInfo)
17019 {
17020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17021 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17022 VOS_ASSERT(0);
17023 return VOS_STATUS_E_NOMEM;
17024 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17025 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17026 if(NULL == pWdaParams)
17027 {
17028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17029 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17030 VOS_ASSERT(0);
17031 vos_mem_free(pwdiSetRssiFilterReqInfo);
17032 return VOS_STATUS_E_NOMEM;
17033 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17034 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17035 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
17036 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17037
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17038 /* Store Params pass it to WDI */
17039 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
17040 pWdaParams->pWdaContext = pWDA;
17041 /* Store param pointer as passed in by caller */
17042 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17043 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17044 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17045 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17046 if(IS_WDI_STATUS_FAILURE(status))
17047 {
17048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17049 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
17050 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17051 vos_mem_free(pWdaParams->wdaMsgParam);
17052 pWdaParams->wdaWdiApiMsgParam = NULL;
17053 pWdaParams->wdaMsgParam = NULL;
17054 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17055 return CONVERT_WDI2VOS_STATUS(status) ;
17056}
17057
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17058/*
17059 * FUNCTION: WDA_ProcessUpdateScanParams
17060 * Request to WDI to update Scan Parameters
17061 */
17062VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
17063 tSirUpdateScanParams *pUpdateScanParams)
17064{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17065 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17066 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
17067 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
17068 sizeof(WDI_UpdateScanParamsInfoType)) ;
17069 tWDA_ReqParams *pWdaParams ;
17070 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17072 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17073 if(NULL == wdiUpdateScanParamsInfoType)
17074 {
17075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17076 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17077 VOS_ASSERT(0);
17078 return VOS_STATUS_E_NOMEM;
17079 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17080 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17081 if ( NULL == pWdaParams )
17082 {
17083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17084 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17085 VOS_ASSERT(0);
17086 vos_mem_free(wdiUpdateScanParamsInfoType);
17087 return VOS_STATUS_E_NOMEM;
17088 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17089 //
17090 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
17091 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17093 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
17094 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
17095 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]17096 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17097 pUpdateScanParams->b11dEnabled,
17098 pUpdateScanParams->b11dResolved,
17099 pUpdateScanParams->ucChannelCount,
17100 pUpdateScanParams->usPassiveMinChTime,
17101 pUpdateScanParams->usPassiveMaxChTime,
17102 pUpdateScanParams->usActiveMinChTime,
17103 pUpdateScanParams->usActiveMaxChTime,
17104 sizeof(tSirUpdateScanParams),
17105 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
17106
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17107 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
17108 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17109 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
17110 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17111 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
17112 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17113 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
17114 pUpdateScanParams->usActiveMaxChTime;
17115 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
17116 pUpdateScanParams->usActiveMinChTime;
17117 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
17118 pUpdateScanParams->usPassiveMaxChTime;
17119 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
17120 pUpdateScanParams->usPassiveMinChTime;
17121
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17122 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]17123 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
17124 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17125
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17126 for ( i = 0; i <
17127 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
17128 i++)
17129 {
17130 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17131 "Update Scan Parameters channel: %d",
17132 pUpdateScanParams->aChannels[i]);
17133
17134 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
17135 pUpdateScanParams->aChannels[i];
17136 }
17137
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17138 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
17139 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17140
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17141 /* Store Params pass it to WDI */
17142 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
17143 pWdaParams->pWdaContext = pWDA;
17144 /* Store param pointer as passed in by caller */
17145 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17146
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17147
17148
17149 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17150 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17151 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17152 if(IS_WDI_STATUS_FAILURE(status))
17153 {
17154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17155 "Failure in Update Scan Params EQ WDI API, free all the memory " );
17156 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17157 vos_mem_free(pWdaParams->wdaMsgParam);
17158 vos_mem_free(pWdaParams);
17159 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17160 return CONVERT_WDI2VOS_STATUS(status) ;
17161}
17162#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17163
17164#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
17165/*
17166 * FUNCTION: WDA_RoamOffloadScanReqCallback
17167 *
17168 */
17169void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
17170{
17171 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17172 vos_msg_t vosMsg;
17173 wpt_uint8 reason = 0;
17174
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]17175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17176 "<------ %s " ,__func__);
17177 if (NULL == pWdaParams)
17178 {
17179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17180 "%s: pWdaParams received NULL", __func__);
17181 VOS_ASSERT(0) ;
17182 return ;
17183 }
17184 if ( pWdaParams != NULL )
17185 {
17186 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
17187 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17188 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17189 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17190 }
17191 if ( pWdaParams->wdaMsgParam != NULL)
17192 {
17193 vos_mem_free(pWdaParams->wdaMsgParam);
17194 }
17195
17196 vos_mem_free(pWdaParams) ;
17197 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17198 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
17199 vosMsg.bodyptr = NULL;
17200 if (WDI_STATUS_SUCCESS != status)
17201 {
17202 reason = 0;
17203 }
17204 vosMsg.bodyval = reason;
17205 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
17206 {
17207 /* free the mem and return */
17208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]17209 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17210 }
17211
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17212 return ;
17213}
17214#endif
17215
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17216/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17217 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17218 *
17219 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17220void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17221{
17222 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17223
17224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17225 "<------ %s " ,__func__);
17226
17227 if(NULL == pWdaParams)
17228 {
17229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17230 "%s: pWdaParams received NULL", __func__);
17231 VOS_ASSERT(0);
17232 return;
17233 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17234
17235 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17236 vos_mem_free(pWdaParams->wdaMsgParam);
17237 vos_mem_free(pWdaParams);
17238
17239 return;
17240}
17241/*
17242 * FUNCTION: WDA_SetPowerParamsReqCallback
17243 * Free memory.
17244 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
17245 */
17246void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
17247{
17248 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17249
17250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17251 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17252
17253 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17254 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17256 "%s: pWdaParams received NULL", __func__);
17257 VOS_ASSERT(0);
17258 return;
17259 }
17260
17261 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17262 {
17263 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17264 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17265 vos_mem_free(pWdaParams);
17266 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17267
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17268 return;
17269}
17270
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17271#ifdef WLAN_FEATURE_PACKET_FILTERING
17272/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17273 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17274 *
17275 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17276void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17277 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
17278 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17279{
17280 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17282 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17283 if(NULL == pWdaParams)
17284 {
17285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17286 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17287 VOS_ASSERT(0) ;
17288 return ;
17289 }
17290
17291 vos_mem_free(pWdaParams->wdaMsgParam) ;
17292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17293 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17294 //print a msg, nothing else to do
17295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17296 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17297 return ;
17298}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17299/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17300 * FUNCTION: WDA_8023MulticastListReqCallback
17301 * Free memory.
17302 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
17303 */
17304void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
17305{
17306 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17307
17308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17309 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17310
17311 if(NULL == pWdaParams)
17312 {
17313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17314 "%s: pWdaParams received NULL", __func__);
17315 VOS_ASSERT(0);
17316 return;
17317 }
17318
17319 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17320 {
17321 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17322 vos_mem_free(pWdaParams->wdaMsgParam);
17323 vos_mem_free(pWdaParams);
17324 }
17325
17326 return;
17327}
17328/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17329 * FUNCTION: WDA_Process8023MulticastListReq
17330 * Request to WDI to add 8023 Multicast List
17331 */
17332VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
17333 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
17334{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17335 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17336 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
17337 tWDA_ReqParams *pWdaParams ;
17338 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17340 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17341 pwdiFltPktSetMcListReqParamsType =
17342 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
17343 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
17344 ) ;
17345 if(NULL == pwdiFltPktSetMcListReqParamsType)
17346 {
17347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17348 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17349 return VOS_STATUS_E_NOMEM;
17350 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17351 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17352 if(NULL == pWdaParams)
17353 {
17354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17355 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17356 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
17357 return VOS_STATUS_E_NOMEM;
17358 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17359
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17360 //
17361 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
17362 //
17363 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17364 pRcvFltMcAddrList->ulMulticastAddrCnt;
17365
17366 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
17367 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
17368 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
17369 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
17370
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17371 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
17372 {
17373 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
17374 &(pRcvFltMcAddrList->multicastAddr[i]),
17375 sizeof(tSirMacAddr));
17376 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17377 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
17378 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17379
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17380 /* Store Params pass it to WDI */
17381 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
17382 pWdaParams->pWdaContext = pWDA;
17383 /* Store param pointer as passed in by caller */
17384 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17385 status = WDI_8023MulticastListReq(
17386 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17387 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17388 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17389 if(IS_WDI_STATUS_FAILURE(status))
17390 {
17391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17392 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
17393 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17394 vos_mem_free(pWdaParams->wdaMsgParam);
17395 vos_mem_free(pWdaParams);
17396 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17397 return CONVERT_WDI2VOS_STATUS(status) ;
17398}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17399/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17400 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17401 *
17402 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17403void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17404 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
17405 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17406{
17407 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17409 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17410 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17411 if(NULL == pWdaParams)
17412 {
17413 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17414 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17415 VOS_ASSERT(0) ;
17416 return ;
17417 }
17418
17419 vos_mem_free(pWdaParams->wdaMsgParam) ;
17420 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17421 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17422 //print a msg, nothing else to do
17423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17424 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17425 return ;
17426}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17427
17428/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17429 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
17430 * Free memory.
17431 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17432 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17433void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17434 void* pUserData)
17435{
17436 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17437
17438 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17439 "<------ %s, wdiStatus: %d",
17440 __func__, wdiStatus);
17441
17442 if (NULL == pWdaParams)
17443 {
17444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17445 "%s: Invalid pWdaParams pointer", __func__);
17446 VOS_ASSERT(0);
17447 return;
17448 }
17449
17450 if (IS_WDI_STATUS_FAILURE(wdiStatus))
17451 {
17452 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17453 vos_mem_free(pWdaParams->wdaMsgParam);
17454 vos_mem_free(pWdaParams);
17455 }
17456
17457 return;
17458}
17459
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17460/*
17461 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
17462 * Request to WDI to set Receive Filters
17463 */
17464VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
17465 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
17466{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17467 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17468 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
17469 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
17470 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
17471 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
17472 tWDA_ReqParams *pWdaParams ;
17473 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17475 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17476 if(NULL == pwdiSetRcvPktFilterReqParamsType)
17477 {
17478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17479 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17480 VOS_ASSERT(0);
17481 return VOS_STATUS_E_NOMEM;
17482 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17483 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17484 if(NULL == pWdaParams)
17485 {
17486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17487 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17488 VOS_ASSERT(0);
17489 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
17490 return VOS_STATUS_E_NOMEM;
17491 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17492 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
17493 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
17494 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
17495 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17496 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
17497 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
17498
17499 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
17500 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17501
17502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17503 "FID %d FT %d NParams %d CT %d",
17504 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
17505 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
17506 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
17507 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17508 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
17509 {
17510 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
17511 &pRcvPktFilterCfg->paramsData[i],
17512 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]17514 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17515 pwdiSetRcvPktFilterReqParamsType->
17516 wdiPktFilterCfg.paramsData[i].protocolLayer,
17517 pwdiSetRcvPktFilterReqParamsType->
17518 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]17520 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17521 pwdiSetRcvPktFilterReqParamsType->
17522 wdiPktFilterCfg.paramsData[i].dataOffset,
17523 pwdiSetRcvPktFilterReqParamsType->
17524 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]17526 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17527 pwdiSetRcvPktFilterReqParamsType->
17528 wdiPktFilterCfg.paramsData[i].compareData[0],
17529 pwdiSetRcvPktFilterReqParamsType->
17530 wdiPktFilterCfg.paramsData[i].compareData[1],
17531 pwdiSetRcvPktFilterReqParamsType->
17532 wdiPktFilterCfg.paramsData[i].compareData[2],
17533 pwdiSetRcvPktFilterReqParamsType->
17534 wdiPktFilterCfg.paramsData[i].compareData[3],
17535 pwdiSetRcvPktFilterReqParamsType->
17536 wdiPktFilterCfg.paramsData[i].compareData[4],
17537 pwdiSetRcvPktFilterReqParamsType->
17538 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]17540 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17541 pwdiSetRcvPktFilterReqParamsType->
17542 wdiPktFilterCfg.paramsData[i].dataMask[0],
17543 pwdiSetRcvPktFilterReqParamsType->
17544 wdiPktFilterCfg.paramsData[i].dataMask[1],
17545 pwdiSetRcvPktFilterReqParamsType->
17546 wdiPktFilterCfg.paramsData[i].dataMask[2],
17547 pwdiSetRcvPktFilterReqParamsType->
17548 wdiPktFilterCfg.paramsData[i].dataMask[3],
17549 pwdiSetRcvPktFilterReqParamsType->
17550 wdiPktFilterCfg.paramsData[i].dataMask[4],
17551 pwdiSetRcvPktFilterReqParamsType->
17552 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17553 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17554 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17555 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17556 /* Store Params pass it to WDI */
17557 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
17558 pWdaParams->pWdaContext = pWDA;
17559 /* Store param pointer as passed in by caller */
17560 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17561 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17562 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17563 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17564 if(IS_WDI_STATUS_FAILURE(status))
17565 {
17566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17567 "Failure in SetFilter(),free all the memory,status %d ",status);
17568 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17569 vos_mem_free(pWdaParams->wdaMsgParam);
17570 vos_mem_free(pWdaParams);
17571 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17572 return CONVERT_WDI2VOS_STATUS(status) ;
17573}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17574/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17575 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17576 *
17577 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17578void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17579 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
17580 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17581{
17582 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17583 tWDA_CbContext *pWDA;
17584 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
17585 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
17586 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
17587 tANI_U8 i;
17588 vos_msg_t vosMsg;
17589
17590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17591 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17592 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
17593
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17594 if(NULL == pRcvFltPktMatchCntRsp)
17595 {
17596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17597 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17598 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17599 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17600 return ;
17601 }
17602
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17603 if(NULL == pWdaParams)
17604 {
17605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17606 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17607 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17608 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17609 return ;
17610 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17611 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
17612 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17613 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
17614 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
17615
17616 /* Message Header */
17617 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
17618 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
17619
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17620 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17621
17622 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
17623 {
17624 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
17625 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
17626 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17627 /* VOS message wrapper */
17628 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
17629 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
17630 vosMsg.bodyval = 0;
17631 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
17632 {
17633 /* free the mem and return */
17634 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
17635 }
17636
17637 vos_mem_free(pWdaParams->wdaMsgParam) ;
17638 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17639 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17640
17641 return;
17642}
17643/*
17644 * FUNCTION: WDA_FilterMatchCountReqCallback
17645 * Free memory and send RSP back to SME.
17646 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
17647 */
17648void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
17649{
17650 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17651 vos_msg_t vosMsg;
17652
17653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17654 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17655
17656 if(NULL == pWdaParams)
17657 {
17658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17659 "%s: pWdaParams received NULL", __func__);
17660 VOS_ASSERT(0);
17661 return;
17662 }
17663
17664 /* VOS message wrapper */
17665 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
17666 vosMsg.bodyptr = NULL;
17667 vosMsg.bodyval = 0;
17668
17669 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17670 {
17671 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17672 vos_mem_free(pWdaParams->wdaMsgParam);
17673 vos_mem_free(pWdaParams);
17674 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
17675 }
17676
17677 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17678}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17679/*
17680 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
17681 * Request to WDI to get PC Filter Match Count
17682 */
17683VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
17684{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17685 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17686 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
17687 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
17688 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17690 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17691 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
17692 {
17693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17694 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17695 VOS_ASSERT(0);
17696 return VOS_STATUS_E_NOMEM;
17697 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17698 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17699 if(NULL == pWdaParams)
17700 {
17701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17702 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17703 VOS_ASSERT(0);
17704 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
17705 return VOS_STATUS_E_NOMEM;
17706 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17707
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17708 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
17709 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17710
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17711 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
17712 pRcvFltPktMatchRsp->bssId,
17713 sizeof(wpt_macAddr));
17714
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17715 /* Store Params pass it to WDI */
17716 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
17717 pWdaParams->pWdaContext = pWDA;
17718 /* Store param pointer as passed in by caller */
17719 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17720 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17721 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17722 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17723 if(IS_WDI_STATUS_FAILURE(status))
17724 {
17725 /* failure returned by WDI API */
17726 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17727 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
17728 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17729 vos_mem_free(pWdaParams) ;
17730 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
17731 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
17732 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17733 return CONVERT_WDI2VOS_STATUS(status) ;
17734}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17735/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17736 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17737 *
17738 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17739void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17740 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
17741 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17742{
17743 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17745 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17746/* WDA_VOS_ASSERT(NULL != pWdaParams); */
17747 if(NULL == pWdaParams)
17748 {
17749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17750 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17751 VOS_ASSERT(0) ;
17752 return ;
17753 }
17754
17755 vos_mem_free(pWdaParams->wdaMsgParam) ;
17756 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17757 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17758 //print a msg, nothing else to do
17759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17760 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17761 return ;
17762}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17763/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17764 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
17765 * Free memory.
17766 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
17767 */
17768void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
17769{
17770 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17771
17772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17773 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17774
17775 if(NULL == pWdaParams)
17776 {
17777 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17778 "%s: Invalid pWdaParams pointer", __func__);
17779 VOS_ASSERT(0);
17780 return;
17781 }
17782
17783 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17784 {
17785 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17786 vos_mem_free(pWdaParams->wdaMsgParam);
17787 vos_mem_free(pWdaParams);
17788 }
17789
17790 return;
17791}
17792/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17793 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
17794 * Request to WDI to clear Receive Filters
17795 */
17796VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
17797 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
17798{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17799 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17800 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
17801 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
17802 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17804 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17805 if(NULL == pwdiRcvFltPktClearReqParamsType)
17806 {
17807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17808 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17809 VOS_ASSERT(0);
17810 return VOS_STATUS_E_NOMEM;
17811 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17812 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17813 if(NULL == pWdaParams)
17814 {
17815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17816 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17817 VOS_ASSERT(0);
17818 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
17819 return VOS_STATUS_E_NOMEM;
17820 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17821 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
17822 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17823 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
17824 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
17825 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
17826 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17827
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17828 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17829 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17830 /* Store Params pass it to WDI */
17831 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
17832 pWdaParams->pWdaContext = pWDA;
17833 /* Store param pointer as passed in by caller */
17834 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17835 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17836 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17837 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17838 if(IS_WDI_STATUS_FAILURE(status))
17839 {
17840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17841 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
17842 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]17843 vos_mem_free(pWdaParams->wdaMsgParam);
17844 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17845 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17846 return CONVERT_WDI2VOS_STATUS(status) ;
17847}
17848#endif // WLAN_FEATURE_PACKET_FILTERING
17849
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17850/*
17851 * FUNCTION: WDA_ProcessSetPowerParamsReq
17852 * Request to WDI to set power params
17853 */
17854VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
17855 tSirSetPowerParamsReq *pPowerParams)
17856{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17857 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17858 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
17859 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17860 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17862 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17863 if(NULL == pwdiSetPowerParamsReqInfo)
17864 {
17865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17866 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17867 VOS_ASSERT(0);
17868 return VOS_STATUS_E_NOMEM;
17869 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17870 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17871 if(NULL == pWdaParams)
17872 {
17873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17874 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17875 VOS_ASSERT(0);
17876 vos_mem_free(pwdiSetPowerParamsReqInfo);
17877 return VOS_STATUS_E_NOMEM;
17878 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17879
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17880
17881 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
17882 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17883 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
17884 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17885 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
17886 pPowerParams->uListenInterval;
17887 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
17888 pPowerParams->uBcastMcastFilter;
17889 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
17890 pPowerParams->uEnableBET;
17891 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
17892 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]17893 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
17894 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17895 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
17896 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17897
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17898 /* Store Params pass it to WDI */
17899 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
17900 pWdaParams->pWdaContext = pWDA;
17901 /* Store param pointer as passed in by caller */
17902 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17903 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17904 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17905 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17906 if(IS_WDI_STATUS_FAILURE(status))
17907 {
17908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17909 "Failure in Set power params REQ WDI API, free all the memory " );
17910 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17911 vos_mem_free(pWdaParams->wdaMsgParam);
17912 pWdaParams->wdaWdiApiMsgParam = NULL;
17913 pWdaParams->wdaMsgParam = NULL;
17914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17915 return CONVERT_WDI2VOS_STATUS(status) ;
17916}
17917
17918/*
17919 * FUNCTION: WDA_SetTmLevelRspCallback
17920 * Set TM Level response
17921 */
17922void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
17923{
17924 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17925
17926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17927 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17928
17929 if(NULL == pWdaParams)
17930 {
17931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17932 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17933 VOS_ASSERT(0) ;
17934 return ;
17935 }
17936
17937 /* Dose not need to send notification to upper layer
17938 * Just free allocated resources */
17939 if( pWdaParams != NULL )
17940 {
17941 if( pWdaParams->wdaWdiApiMsgParam != NULL )
17942 {
17943 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17944 }
17945 vos_mem_free(pWdaParams->wdaMsgParam) ;
17946 vos_mem_free(pWdaParams) ;
17947 }
17948}
17949
17950/*
17951 * FUNCTION: WDA_ProcessSetTmLevelReq
17952 * Set TM Level request
17953 */
17954VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
17955 tAniSetTmLevelReq *setTmLevelReq)
17956{
17957 WDI_Status status = WDI_STATUS_SUCCESS ;
17958 tWDA_ReqParams *pWdaParams ;
17959 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
17960 (WDI_SetTmLevelReqType *)vos_mem_malloc(
17961 sizeof(WDI_SetTmLevelReqType)) ;
17962 if(NULL == wdiSetTmLevelReq)
17963 {
17964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17965 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17966 VOS_ASSERT(0);
17967 return VOS_STATUS_E_NOMEM;
17968 }
17969
17970 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17971 if(NULL == pWdaParams)
17972 {
17973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17974 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17975 VOS_ASSERT(0);
17976 vos_mem_free(wdiSetTmLevelReq);
17977 return VOS_STATUS_E_NOMEM;
17978 }
17979
17980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17981 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17982
17983 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
17984 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
17985
17986 pWdaParams->pWdaContext = pWDA;
17987 pWdaParams->wdaMsgParam = setTmLevelReq;
17988 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
17989
17990 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
17991 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
17992
17993 if(IS_WDI_STATUS_FAILURE(status))
17994 {
17995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]17996 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17997 vos_mem_free(pWdaParams->wdaMsgParam) ;
17998 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17999 vos_mem_free(pWdaParams) ;
18000 }
18001
18002 return CONVERT_WDI2VOS_STATUS(status) ;
18003}
18004
18005VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
18006 tpTxControlParams pTxCtrlParam)
18007{
18008 VOS_STATUS wdaStatus;
18009
18010 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18011 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18012 if( pTxCtrlParam == NULL )
18013 {
18014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18015 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18016 return VOS_STATUS_E_FAILURE;
18017 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18018 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
18019 {
18020 wdaStatus = WDA_SuspendDataTx(pWDA);
18021 }
18022 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
18023 {
18024 wdaStatus = WDA_ResumeDataTx(pWDA);
18025 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18026 return wdaStatus;
18027}
18028
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18029void WDA_FWLoggingDXEdoneInd(v_U32_t logType)
Mihir Shete5affadc2015-05-29 20:54:57 +0530[diff] [blame]18030{
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18031 WDI_Status status;
18032 status = WDI_FWLoggingDXEdoneInd(logType);
18033
Hanumantha Reddy Pothula5e509402015-09-23 09:45:57 +0530[diff] [blame]18034 if (!(WDI_STATUS_SUCCESS_SYNC == status || WDI_STATUS_PENDING == status))
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18035 {
18036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18037 FL("Failure status %d"), status);
18038 }
Mihir Shete5affadc2015-05-29 20:54:57 +0530[diff] [blame]18039}
18040
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18041 /* FUNCTION WDA_featureCapsExchange
18042 * WDA API to invoke capability exchange between host and FW.
18043 */
18044void WDA_featureCapsExchange(v_PVOID_t pVosContext)
18045{
18046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18047 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18048 WDI_featureCapsExchangeReq( NULL, pVosContext);
18049}
18050
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]18051/* FUNCTION WDA_disableCapablityFeature
18052 * WDA API to diable Active mode offload in host.
18053 */
18054void WDA_disableCapablityFeature(tANI_U8 feature_index)
18055{
18056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18057 "%s:enter", __func__ );
18058 WDI_disableCapablityFeature(feature_index);
18059}
18060
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18061 /* FUNCTION WDA_getHostWlanFeatCaps
18062 * Wrapper for WDI API, that will return if the feature (enum value).passed
18063 * to this API is supported or not in Host
18064 * return value
18065 * 0 - implies feature is NOT Supported
18066 * any non zero value - implies feature is SUPPORTED
18067 */
18068tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
18069{
18070 return WDI_getHostWlanFeatCaps(featEnumValue);
18071}
18072
18073 /* FUNCTION WDA_getFwWlanFeatCaps
18074 * Wrapper for WDI API, that will return if the feature (enum value).passed
18075 * to this API is supported or not in FW
18076 * return value
18077 * 0 - implies feature is NOT Supported
18078 * any non zero value - implies feature is SUPPORTED
18079 */
18080tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
18081{
18082 return WDI_getFwWlanFeatCaps(featEnumValue);
18083}
18084
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]18085
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18086/*
18087 * FUNCTION: WDA_shutdown
18088 * Shutdown WDA/WDI without handshaking with Riva.
18089 * Synchronous function.
18090 */
18091VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
18092{
18093 WDI_Status wdiStatus;
18094 //tANI_U8 eventIdx = 0;
18095 VOS_STATUS status = VOS_STATUS_SUCCESS;
18096 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18097 if (NULL == pWDA)
18098 {
18099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18100 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18101 VOS_ASSERT(0);
18102 return VOS_STATUS_E_FAILURE;
18103 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18104 /* FTM mode stay START_STATE */
18105 if( (WDA_READY_STATE != pWDA->wdaState) &&
18106 (WDA_INIT_STATE != pWDA->wdaState) &&
18107 (WDA_START_STATE != pWDA->wdaState) )
18108 {
18109 VOS_ASSERT(0);
18110 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18111
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18112 if (eDRIVER_TYPE_MFG != pWDA->driverMode)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18113 {
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18114 if(VOS_TRUE == pWDA->wdaTimersCreated)
18115 {
18116 wdaDestroyTimers(pWDA);
18117 pWDA->wdaTimersCreated = VOS_FALSE;
18118 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18119 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]18120 else
18121 {
18122 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18123 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18124
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18125 /* call WDI shutdown */
18126 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18127 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
18128 {
18129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18130 "error in WDA Stop" );
18131 status = VOS_STATUS_E_FAILURE;
18132 }
18133 /* WDI stop is synchrnous, shutdown is complete when it returns */
18134 pWDA->wdaState = WDA_STOP_STATE;
18135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18136 /* shutdown should perform the stop & close actions. */
18137 /* Destroy the event */
18138 status = vos_event_destroy(&pWDA->txFrameEvent);
18139 if(!VOS_IS_STATUS_SUCCESS(status))
18140 {
18141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18142 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18143 status = VOS_STATUS_E_FAILURE;
18144 }
18145 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
18146 if(!VOS_IS_STATUS_SUCCESS(status))
18147 {
18148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18149 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18150 status = VOS_STATUS_E_FAILURE;
18151 }
18152 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
18153 if(!VOS_IS_STATUS_SUCCESS(status))
18154 {
18155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18156 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18157 status = VOS_STATUS_E_FAILURE;
18158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18159 /* free WDA context */
18160 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
18161 if ( !VOS_IS_STATUS_SUCCESS(status) )
18162 {
18163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18164 "error in WDA close " );
18165 status = VOS_STATUS_E_FAILURE;
18166 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18167 return status;
18168}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18169
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18170/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18171 * FUNCTION: WDA_setNeedShutdown
18172 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18173 */
18174
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18175void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18176{
18177 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]18178 if(pWDA == NULL)
18179 {
18180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18181 "Could not get the WDA Context pointer" );
18182 return;
18183 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18184 pWDA->needShutdown = TRUE;
18185}
18186/*
18187 * FUNCTION: WDA_needShutdown
18188 * WDA needs a shutdown
18189 */
18190
18191v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
18192{
18193 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]18194 if(pWDA == NULL)
18195 {
18196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18197 "Could not get the WDA Context pointer" );
18198 return 0;
18199 }
18200 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18201}
18202
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18203#ifdef WLAN_FEATURE_11AC
18204/*
18205 * FUNCTION: WDA_SetBeaconFilterReqCallback
18206 *
18207 */
18208void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
18209{
18210 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18212 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18213 if(NULL == pWdaParams)
18214 {
18215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18216 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18217 VOS_ASSERT(0) ;
18218 return ;
18219 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18220
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18221 vos_mem_free(pWdaParams->wdaMsgParam) ;
18222 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18223 vos_mem_free(pWdaParams) ;
18224 /*
18225 * No respone required for SetBeaconFilter req so just free the request
18226 * param here
18227 */
18228
18229 return ;
18230}
18231
18232VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
18233 tUpdateVHTOpMode *pData)
18234{
18235 WDI_Status status = WDI_STATUS_SUCCESS ;
18236 tWDA_ReqParams *pWdaParams ;
18237 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
18238 sizeof(WDI_UpdateVHTOpMode)) ;
18239 if(NULL == wdiTemp)
18240 {
18241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18242 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18243 VOS_ASSERT(0);
18244 return VOS_STATUS_E_NOMEM;
18245 }
18246 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18247 if(NULL == pWdaParams)
18248 {
18249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18250 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18251 VOS_ASSERT(0);
18252 vos_mem_free(wdiTemp);
18253 return VOS_STATUS_E_NOMEM;
18254 }
Abhishek Singhdf8eb312014-11-15 00:49:28 +0530[diff] [blame]18255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18256 "------> %s Opmode = %d and staid = %d" ,
18257 __func__, pData->opMode, pData->staId);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18258 wdiTemp->opMode = pData->opMode;
18259 wdiTemp->staId = pData->staId;
18260
18261 pWdaParams->pWdaContext = pWDA;
18262 /* Store Req pointer, as this will be used for response */
18263 pWdaParams->wdaMsgParam = (void *)pData;
18264 /* store Params pass it to WDI */
18265 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
18266
18267 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
18268
18269 if(IS_WDI_STATUS_FAILURE(status))
18270 {
18271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18272 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
18273 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
18274 vos_mem_free(pWdaParams->wdaMsgParam);
18275 vos_mem_free(pWdaParams);
18276 }
18277 return CONVERT_WDI2VOS_STATUS(status) ;
18278}
18279#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18280
18281/*==========================================================================
18282 FUNCTION WDA_TransportChannelDebug
18283
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]18284 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18285 Display Transport Channel debugging information
18286 User may request to display DXE channel snapshot
18287 Or if host driver detects any abnormal stcuk may display
18288
18289 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]18290 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]18291 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18292 debugFlags : Enable stall detect features
18293 defined by WPAL_DeviceDebugFlags
18294 These features may effect
18295 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18296
18297 RETURN VALUE
18298 NONE
18299
18300===========================================================================*/
18301void WDA_TransportChannelDebug
18302(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]18303 tpAniSirGlobal pMac,
18304 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18305 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18306)
18307{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18308 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18309 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]18310}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]18311
18312/*==========================================================================
18313 FUNCTION WDA_SetEnableSSR
18314
18315 DESCRIPTION
18316 API to enable/disable SSR on WDI timeout
18317
18318 PARAMETERS
18319 enableSSR : enable/disable SSR
18320
18321 RETURN VALUE
18322 NONE
18323
18324===========================================================================*/
18325void WDA_SetEnableSSR(v_BOOL_t enableSSR)
18326{
18327 WDI_SetEnableSSR(enableSSR);
18328}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]18329
18330#ifdef FEATURE_WLAN_LPHB
18331/*
18332 * FUNCTION: WDA_LPHBconfRspCallback
18333 *
18334 */
18335void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
18336{
18337 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18338
18339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18340 "<------ %s " ,__func__);
18341 if (NULL == pWdaParams)
18342 {
18343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18344 "%s: pWdaParams received NULL", __func__);
18345 VOS_ASSERT(0) ;
18346 return ;
18347 }
18348
18349 /* Do not need to send notification to upper layer
18350 * Just free allocated resources */
18351 if (pWdaParams != NULL)
18352 {
18353 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18354 {
18355 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18356 }
18357 vos_mem_free(pWdaParams->wdaMsgParam) ;
18358 vos_mem_free(pWdaParams) ;
18359 }
18360
18361 return;
18362}
18363
18364/*
18365 * FUNCTION: WDA_ProcessLPHBConfReq
18366 *
18367 */
18368VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
18369 tSirLPHBReq *pData)
18370{
18371 WDI_Status wdiStatus;
18372 tWDA_ReqParams *pWdaParams ;
18373
18374 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18375 "------> %s " , __func__);
18376
18377 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18378 if (NULL == pWdaParams)
18379 {
18380 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18381 "%s: VOS MEM Alloc Failure", __func__);
18382 VOS_ASSERT(0);
18383 vos_mem_free(pData);
18384 return VOS_STATUS_E_NOMEM;
18385 }
18386
18387 pWdaParams->pWdaContext = pWDA;
18388 pWdaParams->wdaMsgParam = (void *)pData;
18389 pWdaParams->wdaWdiApiMsgParam = NULL;
18390
18391 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
18392 if (WDI_STATUS_PENDING == wdiStatus)
18393 {
18394 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18395 "Pending received for %s:%d ", __func__, __LINE__);
18396 }
18397 else if (WDI_STATUS_SUCCESS != wdiStatus)
18398 {
18399 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18400 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
18401 vos_mem_free(pWdaParams->wdaMsgParam);
18402 vos_mem_free(pWdaParams);
18403 }
18404
18405 return CONVERT_WDI2VOS_STATUS(wdiStatus);
18406}
18407#endif /* FEATURE_WLAN_LPHB */
18408
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]18409void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
18410 void* pUserData)
18411{
18412 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
18413
18414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18415 "<------ %s " ,__func__);
18416 if (NULL == pBcnMissRateInfo)
18417 {
18418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18419 "%s: pWdaParams received NULL", __func__);
18420 VOS_ASSERT(0) ;
18421 return ;
18422 }
18423 if (pBcnMissRateInfo->callback)
18424 {
18425 pBcnMissRateInfo->callback(status, bcnMissRate,
18426 pBcnMissRateInfo->data);
18427 }
18428 vos_mem_free(pUserData);
18429
18430 return;
18431}
18432
18433v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
18434 tSirBcnMissRateReq *pData)
18435{
18436 WDI_Status wdiStatus;
18437 tSirBcnMissRateInfo *pBcnMissRateInfo;
18438
18439 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18440 "------> %s " , __func__);
18441
18442 pBcnMissRateInfo =
18443 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
18444 if (NULL == pBcnMissRateInfo)
18445 {
18446 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18447 "%s: VOS MEM Alloc Failure", __func__);
18448 VOS_ASSERT(0);
18449 vos_mem_free(pData);
18450 return;
18451 }
18452
18453 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
18454 pBcnMissRateInfo->data = pData->data;
18455
18456 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
18457 WDA_GetBcnMissRateCallback,
18458 pData->bssid);
18459 if (WDI_STATUS_PENDING == wdiStatus)
18460 {
18461 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18462 "Pending received for %s:%d ", __func__, __LINE__);
18463 }
18464 else if (WDI_STATUS_SUCCESS != wdiStatus)
18465 {
18466 if (pBcnMissRateInfo->callback)
18467 {
18468 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
18469 -1, pBcnMissRateInfo->data);
18470 }
18471 }
18472 vos_mem_free(pData);
18473}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]18474
18475#ifdef WLAN_FEATURE_EXTSCAN
18476
18477/*==========================================================================
18478 FUNCTION WDA_EXTScanStartRspCallback
18479
18480 DESCRIPTION
18481 API to send EXTScan Start Response to HDD
18482
18483 PARAMETERS
18484 pEventData: Response from FW
18485 pUserData:
18486===========================================================================*/
18487void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
18488{
18489 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18490 tWDA_CbContext *pWDA = NULL;
18491 void *pCallbackContext;
18492 tpAniSirGlobal pMac;
18493
18494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18495 "%s:", __func__);
18496 if (NULL == pWdaParams)
18497 {
18498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18499 "%s: pWdaParams received NULL", __func__);
18500 VOS_ASSERT(0);
18501 return;
18502 }
18503
18504 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18505
18506 if (NULL == pWDA)
18507 {
18508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18509 "%s: pWDA received NULL", __func__);
18510 VOS_ASSERT(0);
18511 goto error;
18512 }
18513
18514 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18515 if (NULL == pMac)
18516 {
18517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18518 "%s:pMac is NULL", __func__);
18519 VOS_ASSERT(0);
18520 goto error;
18521 }
18522
18523 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18524
18525 if (pMac->sme.pEXTScanIndCb)
18526 {
18527 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
18528 pEventData);
18529 }
18530 else
18531 {
18532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18533 "%s:HDD callback is null", __func__);
18534 VOS_ASSERT(0);
18535 }
18536
18537error:
18538
18539 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18540 {
18541 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18542 }
18543 if (pWdaParams->wdaMsgParam != NULL)
18544 {
18545 vos_mem_free(pWdaParams->wdaMsgParam);
18546 }
18547 vos_mem_free(pWdaParams) ;
18548
18549 return;
18550}
18551
18552/*==========================================================================
18553 FUNCTION WDA_EXTScanStopRspCallback
18554
18555 DESCRIPTION
18556 API to send EXTScan Stop Response to HDD
18557
18558 PARAMETERS
18559 pEventData: Response from FW
18560 pUserData:
18561===========================================================================*/
18562void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
18563{
18564 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18565 tWDA_CbContext *pWDA = NULL;
18566 void *pCallbackContext;
18567 tpAniSirGlobal pMac;
18568
18569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18570 "%s:", __func__);
18571 if (NULL == pWdaParams)
18572 {
18573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18574 "%s: pWdaParams received NULL", __func__);
18575 VOS_ASSERT(0);
18576 return;
18577 }
18578
18579 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18580
18581 if (NULL == pWDA)
18582 {
18583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18584 "%s: pWDA received NULL", __func__);
18585 VOS_ASSERT(0);
18586 goto error;
18587 }
18588
18589 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18590 if (NULL == pMac)
18591 {
18592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18593 "%s:pMac is NULL", __func__);
18594 VOS_ASSERT(0);
18595 goto error;
18596 }
18597 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18598
18599 if (pMac->sme.pEXTScanIndCb)
18600 {
18601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18602 "%s:HDD call back function called", __func__);
18603 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
18604 pEventData);
18605 }
18606 else
18607 {
18608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18609 "%s:HDD callback is null", __func__);
18610 VOS_ASSERT(0);
18611 }
18612
18613error:
18614
18615 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18616 {
18617 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18618 }
18619 if (pWdaParams->wdaMsgParam != NULL)
18620 {
18621 vos_mem_free(pWdaParams->wdaMsgParam);
18622 }
18623 vos_mem_free(pWdaParams) ;
18624
18625
18626 return;
18627}
18628
18629/*==========================================================================
18630 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
18631
18632 DESCRIPTION
18633 API to send EXTScan Get Cached Results Response to HDD
18634
18635 PARAMETERS
18636 pEventData: Response from FW
18637 pUserData:
18638===========================================================================*/
18639void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
18640{
18641 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18642 tWDA_CbContext *pWDA = NULL;
18643 void *pCallbackContext;
18644 tpAniSirGlobal pMac;
18645
18646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18647 "%s: ", __func__);
18648 if (NULL == pWdaParams)
18649 {
18650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18651 "%s: pWdaParams received NULL", __func__);
18652 VOS_ASSERT(0);
18653 return;
18654 }
18655
18656 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18657
18658 if (NULL == pWDA)
18659 {
18660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18661 "%s: pWDA received NULL", __func__);
18662 VOS_ASSERT(0);
18663 goto error;
18664 }
18665
18666 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18667 if (NULL == pMac)
18668 {
18669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18670 "%s:pMac is NULL", __func__);
18671 VOS_ASSERT(0);
18672 goto error;
18673 }
18674
18675 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18676
18677 if (pMac->sme.pEXTScanIndCb)
18678 {
18679 pMac->sme.pEXTScanIndCb(pCallbackContext,
18680 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
18681 pEventData);
18682 }
18683 else
18684 {
18685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18686 "%s:HDD callback is null", __func__);
18687 VOS_ASSERT(0);
18688 }
18689
18690
18691error:
18692
18693 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18694 {
18695 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18696 }
18697 if (pWdaParams->wdaMsgParam != NULL)
18698 {
18699 vos_mem_free(pWdaParams->wdaMsgParam);
18700 }
18701 vos_mem_free(pWdaParams) ;
18702
18703 return;
18704}
18705
18706/*==========================================================================
18707 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
18708
18709 DESCRIPTION
18710 API to send EXTScan Get Capabilities Response to HDD
18711
18712 PARAMETERS
18713 pEventData: Response from FW
18714 pUserData:
18715===========================================================================*/
18716void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
18717{
18718 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18719 tWDA_CbContext *pWDA = NULL;
18720 void *pCallbackContext;
18721 tpAniSirGlobal pMac;
18722
18723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18724 "%s:", __func__);
18725 if (NULL == pWdaParams)
18726 {
18727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18728 "%s: pWdaParams received NULL", __func__);
18729 VOS_ASSERT(0);
18730 return;
18731 }
18732
18733 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18734
18735 if (NULL == pWDA)
18736 {
18737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18738 "%s: pWDA received NULL", __func__);
18739 VOS_ASSERT(0);
18740 goto error;
18741 }
18742
18743 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18744 if (NULL == pMac)
18745 {
18746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18747 "%s:pMac is NULL", __func__);
18748 VOS_ASSERT(0);
18749 goto error;
18750 }
18751
18752 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18753
18754 if (pMac->sme.pEXTScanIndCb)
18755 {
18756 pMac->sme.pEXTScanIndCb(pCallbackContext,
18757 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
18758 pEventData);
18759 }
18760 else
18761 {
18762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18763 "%s:HDD callback is null", __func__);
18764 VOS_ASSERT(0);
18765 }
18766
18767
18768error:
18769
18770 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18771 {
18772 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18773 }
18774 if (pWdaParams->wdaMsgParam != NULL)
18775 {
18776 vos_mem_free(pWdaParams->wdaMsgParam);
18777 }
18778 vos_mem_free(pWdaParams) ;
18779
18780 return;
18781}
18782
18783/*==========================================================================
18784 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
18785
18786 DESCRIPTION
18787 API to send EXTScan Set BSSID Hotlist Response to HDD
18788
18789 PARAMETERS
18790 pEventData: Response from FW
18791 pUserData:
18792===========================================================================*/
18793void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
18794{
18795 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18796 tWDA_CbContext *pWDA = NULL;
18797 void *pCallbackContext;
18798 tpAniSirGlobal pMac;
18799
18800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18801 "%s: ", __func__);
18802 if (NULL == pWdaParams)
18803 {
18804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18805 "%s: pWdaParams received NULL", __func__);
18806 VOS_ASSERT(0) ;
18807 return;
18808 }
18809
18810 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18811
18812 if (NULL == pWDA)
18813 {
18814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18815 "%s: pWDA received NULL", __func__);
18816 VOS_ASSERT(0);
18817 goto error;
18818 }
18819
18820 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18821 if (NULL == pMac)
18822 {
18823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18824 "%s:pMac is NULL", __func__);
18825 VOS_ASSERT(0);
18826 goto error;
18827 }
18828
18829 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18830
18831 if (pMac->sme.pEXTScanIndCb)
18832 {
18833 pMac->sme.pEXTScanIndCb(pCallbackContext,
18834 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
18835 pEventData);
18836 }
18837 else
18838 {
18839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18840 "%s:HDD callback is null", __func__);
18841 VOS_ASSERT(0);
18842 }
18843
18844
18845error:
18846
18847 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18848 {
18849 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18850 }
18851 if (pWdaParams->wdaMsgParam != NULL)
18852 {
18853 vos_mem_free(pWdaParams->wdaMsgParam);
18854 }
18855 vos_mem_free(pWdaParams) ;
18856
18857 return;
18858}
18859
18860/*==========================================================================
18861 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
18862
18863 DESCRIPTION
18864 API to send EXTScan ReSet BSSID Hotlist Response to HDD
18865
18866 PARAMETERS
18867 pEventData: Response from FW
18868 pUserData:
18869===========================================================================*/
18870void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
18871{
18872 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18873 tWDA_CbContext *pWDA = NULL;
18874 void *pCallbackContext;
18875 tpAniSirGlobal pMac;
18876
18877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18878 "%s:", __func__);
18879 if (NULL == pWdaParams)
18880 {
18881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18882 "%s: pWdaParams received NULL", __func__);
18883 VOS_ASSERT(0) ;
18884 return;
18885 }
18886
18887 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18888
18889 if (NULL == pWDA)
18890 {
18891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18892 "%s: pWDA received NULL", __func__);
18893 VOS_ASSERT(0);
18894 goto error;
18895 }
18896
18897 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18898 if (NULL == pMac)
18899 {
18900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18901 "%s:pMac is NULL", __func__);
18902 VOS_ASSERT(0);
18903 goto error;
18904 }
18905
18906 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18907
18908 if (pMac->sme.pEXTScanIndCb)
18909 {
18910 pMac->sme.pEXTScanIndCb(pCallbackContext,
18911 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
18912 pEventData);
18913 }
18914 else
18915 {
18916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18917 "%s:HDD callback is null", __func__);
18918 VOS_ASSERT(0);
18919 }
18920
18921
18922error:
18923
18924 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18925 {
18926 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18927 }
18928 if (pWdaParams->wdaMsgParam != NULL)
18929 {
18930 vos_mem_free(pWdaParams->wdaMsgParam);
18931 }
18932 vos_mem_free(pWdaParams) ;
18933
18934 return;
18935}
18936
18937/*==========================================================================
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]18938 FUNCTION WDA_EXTScanSetSSIDHotlistRspCallback
18939
18940 DESCRIPTION
18941 API to send EXTScan Set SSID Hotlist Response to HDD
18942
18943 PARAMETERS
18944 pEventData: Response from FW
18945 pUserData:
18946===========================================================================*/
18947void WDA_EXTScanSetSSIDHotlistRspCallback(void *pEventData, void* pUserData)
18948{
18949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18950 tWDA_CbContext *pWDA = NULL;
18951 void *pCallbackContext;
18952 tpAniSirGlobal pMac;
18953
18954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18955 "%s: ", __func__);
18956 if (NULL == pWdaParams)
18957 {
18958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18959 "%s: pWdaParams received NULL", __func__);
18960 VOS_ASSERT(0) ;
18961 return;
18962 }
18963
18964 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
18965
18966 if (NULL == pWDA)
18967 {
18968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18969 "%s: pWDA received NULL", __func__);
18970 VOS_ASSERT(0);
18971 goto error;
18972 }
18973
18974 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
18975 if (NULL == pMac)
18976 {
18977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18978 "%s:pMac is NULL", __func__);
18979 VOS_ASSERT(0);
18980 goto error;
18981 }
18982
18983 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
18984
18985 if (pMac->sme.pEXTScanIndCb)
18986 {
18987 pMac->sme.pEXTScanIndCb(pCallbackContext,
18988 WDA_EXTSCAN_SET_SSID_HOTLIST_RSP,
18989 pEventData);
18990 }
18991 else
18992 {
18993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18994 "%s:HDD callback is null", __func__);
18995 VOS_ASSERT(0);
18996 }
18997
18998
18999error:
19000
19001 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19002 {
19003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19004 }
19005 if (pWdaParams->wdaMsgParam != NULL)
19006 {
19007 vos_mem_free(pWdaParams->wdaMsgParam);
19008 }
19009 vos_mem_free(pWdaParams) ;
19010
19011 return;
19012}
19013
19014/*==========================================================================
19015 FUNCTION WDA_EXTScanResetSSIDHotlistRspCallback
19016
19017 DESCRIPTION
19018 API to send EXTScan ReSet SSID Hotlist Response to HDD
19019
19020 PARAMETERS
19021 pEventData: Response from FW
19022 pUserData:
19023===========================================================================*/
19024void WDA_EXTScanResetSSIDHotlistRspCallback(void *pEventData, void* pUserData)
19025{
19026 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19027 tWDA_CbContext *pWDA = NULL;
19028 void *pCallbackContext;
19029 tpAniSirGlobal pMac;
19030
19031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19032 "%s:", __func__);
19033 if (NULL == pWdaParams)
19034 {
19035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19036 "%s: pWdaParams received NULL", __func__);
19037 VOS_ASSERT(0) ;
19038 return;
19039 }
19040
19041 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19042
19043 if (NULL == pWDA)
19044 {
19045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19046 "%s: pWDA received NULL", __func__);
19047 VOS_ASSERT(0);
19048 goto error;
19049 }
19050
19051 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19052 if (NULL == pMac)
19053 {
19054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19055 "%s:pMac is NULL", __func__);
19056 VOS_ASSERT(0);
19057 goto error;
19058 }
19059
19060 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19061
19062 if (pMac->sme.pEXTScanIndCb)
19063 {
19064 pMac->sme.pEXTScanIndCb(pCallbackContext,
19065 WDA_EXTSCAN_RESET_SSID_HOTLIST_RSP,
19066 pEventData);
19067 }
19068 else
19069 {
19070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19071 "%s:HDD callback is null", __func__);
19072 VOS_ASSERT(0);
19073 }
19074
19075
19076error:
19077
19078 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19079 {
19080 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19081 }
19082 if (pWdaParams->wdaMsgParam != NULL)
19083 {
19084 vos_mem_free(pWdaParams->wdaMsgParam);
19085 }
19086 vos_mem_free(pWdaParams) ;
19087
19088 return;
19089}
19090
19091
19092
19093/*==========================================================================
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]19094 FUNCTION WDA_ProcessEXTScanStartReq
19095
19096 DESCRIPTION
19097 API to send EXTScan Start Request to WDI
19098
19099 PARAMETERS
19100 pWDA: Pointer to WDA context
19101 wdaRequest: Pointer to EXTScan req parameters
19102===========================================================================*/
19103VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
19104 tSirEXTScanStartReqParams *wdaRequest)
19105{
19106 WDI_Status status = WDI_STATUS_SUCCESS;
19107 tWDA_ReqParams *pWdaParams;
19108
19109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19110 "%s: ", __func__);
19111 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19112 if (NULL == pWdaParams)
19113 {
19114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19115 "%s: VOS MEM Alloc Failure", __func__);
19116 VOS_ASSERT(0);
19117 return VOS_STATUS_E_NOMEM;
19118 }
19119 pWdaParams->pWdaContext = pWDA;
19120 pWdaParams->wdaMsgParam = wdaRequest;
19121 pWdaParams->wdaWdiApiMsgParam = NULL;
19122
19123 status = WDI_EXTScanStartReq((void *)wdaRequest,
19124 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
19125 (void *)pWdaParams);
19126 if (IS_WDI_STATUS_FAILURE(status))
19127 {
19128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19129 "Failure to request. Free all the memory " );
19130 vos_mem_free(pWdaParams->wdaMsgParam);
19131 vos_mem_free(pWdaParams);
19132 }
19133 return CONVERT_WDI2VOS_STATUS(status);
19134}
19135
19136/*==========================================================================
19137 FUNCTION WDA_ProcessEXTScanStopReq
19138
19139 DESCRIPTION
19140 API to send EXTScan Start Request to WDI
19141
19142 PARAMETERS
19143 pWDA: Pointer to WDA context
19144 wdaRequest: Pointer to EXTScan req parameters
19145===========================================================================*/
19146VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
19147 tSirEXTScanStopReqParams *wdaRequest)
19148{
19149 WDI_Status status = WDI_STATUS_SUCCESS;
19150 tWDA_ReqParams *pWdaParams;
19151
19152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19153 "%s:", __func__);
19154 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19155 if (NULL == pWdaParams)
19156 {
19157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19158 "%s: VOS MEM Alloc Failure", __func__);
19159 VOS_ASSERT(0);
19160 return VOS_STATUS_E_NOMEM;
19161 }
19162 pWdaParams->pWdaContext = pWDA;
19163 pWdaParams->wdaMsgParam = wdaRequest;
19164 pWdaParams->wdaWdiApiMsgParam = NULL;
19165
19166 status = WDI_EXTScanStopReq((void *)wdaRequest,
19167 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
19168 (void *)pWdaParams);
19169 if (IS_WDI_STATUS_FAILURE(status))
19170 {
19171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19172 "Failure to request. Free all the memory " );
19173 vos_mem_free(pWdaParams->wdaMsgParam);
19174 vos_mem_free(pWdaParams);
19175 }
19176 return CONVERT_WDI2VOS_STATUS(status);
19177}
19178
19179/*==========================================================================
19180 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
19181
19182 DESCRIPTION
19183 API to send EXTScan Get Cached Results Request to WDI
19184
19185 PARAMETERS
19186 pWDA: Pointer to WDA context
19187 wdaRequest: Pointer to EXTScan req parameters
19188===========================================================================*/
19189VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
19190 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
19191{
19192 WDI_Status status = WDI_STATUS_SUCCESS;
19193 tWDA_ReqParams *pWdaParams;
19194
19195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19196 "%s: ", __func__);
19197 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19198 if (NULL == pWdaParams)
19199 {
19200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19201 "%s: VOS MEM Alloc Failure", __func__);
19202 VOS_ASSERT(0);
19203 return VOS_STATUS_E_NOMEM;
19204 }
19205 pWdaParams->pWdaContext = pWDA;
19206 pWdaParams->wdaMsgParam = wdaRequest;
19207 pWdaParams->wdaWdiApiMsgParam = NULL;
19208
19209 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
19210 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
19211 (void *)pWdaParams);
19212 if (IS_WDI_STATUS_FAILURE(status))
19213 {
19214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19215 "Failure to request. Free all the memory " );
19216 vos_mem_free(pWdaParams->wdaMsgParam);
19217 vos_mem_free(pWdaParams);
19218 }
19219 return CONVERT_WDI2VOS_STATUS(status);
19220}
19221
19222/*==========================================================================
19223 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
19224
19225 DESCRIPTION
19226 API to send EXTScan Get Capabilities Request to WDI
19227
19228 PARAMETERS
19229 pWDA: Pointer to WDA context
19230 wdaRequest: Pointer to EXTScan req parameters
19231===========================================================================*/
19232VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
19233 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
19234{
19235 WDI_Status status = WDI_STATUS_SUCCESS;
19236 tWDA_ReqParams *pWdaParams;
19237
19238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19239 "%s:", __func__);
19240 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19241 if (NULL == pWdaParams)
19242 {
19243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19244 "%s: VOS MEM Alloc Failure", __func__);
19245 VOS_ASSERT(0);
19246 return VOS_STATUS_E_NOMEM;
19247 }
19248 pWdaParams->pWdaContext = pWDA;
19249 pWdaParams->wdaMsgParam = wdaRequest;
19250 pWdaParams->wdaWdiApiMsgParam = NULL;
19251
19252 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
19253 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
19254 (void *)pWdaParams);
19255 if (IS_WDI_STATUS_FAILURE(status))
19256 {
19257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19258 "Failure to request. Free all the memory " );
19259 vos_mem_free(pWdaParams->wdaMsgParam);
19260 vos_mem_free(pWdaParams);
19261 }
19262 return CONVERT_WDI2VOS_STATUS(status);
19263}
19264
19265/*==========================================================================
19266 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
19267
19268 DESCRIPTION
19269 API to send Set BSSID Hotlist Request to WDI
19270
19271 PARAMETERS
19272 pWDA: Pointer to WDA context
19273 wdaRequest: Pointer to EXTScan req parameters
19274===========================================================================*/
19275VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
19276 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
19277{
19278 WDI_Status status = WDI_STATUS_SUCCESS;
19279 tWDA_ReqParams *pWdaParams;
19280
19281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19282 "%s: ", __func__);
19283 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19284 if (NULL == pWdaParams)
19285 {
19286 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19287 "%s: VOS MEM Alloc Failure", __func__);
19288 VOS_ASSERT(0);
19289 return VOS_STATUS_E_NOMEM;
19290 }
19291 pWdaParams->pWdaContext = pWDA;
19292 pWdaParams->wdaMsgParam = wdaRequest;
19293 pWdaParams->wdaWdiApiMsgParam = NULL;
19294
19295 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
19296 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
19297 (void *)pWdaParams);
19298 if (IS_WDI_STATUS_FAILURE(status))
19299 {
19300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19301 "Failure to request. Free all the memory " );
19302 vos_mem_free(pWdaParams->wdaMsgParam);
19303 vos_mem_free(pWdaParams);
19304 }
19305 return CONVERT_WDI2VOS_STATUS(status);
19306}
19307
19308/*==========================================================================
19309 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
19310
19311 DESCRIPTION
19312 API to send Reset BSSID Hotlist Request to WDI
19313
19314 PARAMETERS
19315 pWDA: Pointer to WDA context
19316 wdaRequest: Pointer to EXTScan req parameters
19317===========================================================================*/
19318VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
19319 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
19320{
19321 WDI_Status status = WDI_STATUS_SUCCESS;
19322 tWDA_ReqParams *pWdaParams;
19323
19324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19325 "%s:", __func__);
19326 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19327 if (NULL == pWdaParams)
19328 {
19329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19330 "%s: VOS MEM Alloc Failure", __func__);
19331 VOS_ASSERT(0);
19332 return VOS_STATUS_E_NOMEM;
19333 }
19334 pWdaParams->pWdaContext = pWDA;
19335 pWdaParams->wdaMsgParam = wdaRequest;
19336 pWdaParams->wdaWdiApiMsgParam = NULL;
19337
19338 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
19339 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
19340 (void *)pWdaParams);
19341 if (IS_WDI_STATUS_FAILURE(status))
19342 {
19343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19344 "Failure to request. Free all the memory " );
19345 vos_mem_free(pWdaParams->wdaMsgParam);
19346 vos_mem_free(pWdaParams);
19347 }
19348 return CONVERT_WDI2VOS_STATUS(status);
19349}
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]19350
19351/*==========================================================================
19352 FUNCTION WDA_ProcessEXTScanSetSSIDHotlistReq
19353
19354 DESCRIPTION
19355 API to send Set SSID Hotlist Request to WDI
19356
19357 PARAMETERS
19358 pWDA: Pointer to WDA context
19359 wdaRequest: Pointer to EXTScan req parameters
19360===========================================================================*/
19361VOS_STATUS WDA_ProcessEXTScanSetSSIDHotlistReq(tWDA_CbContext *pWDA,
19362 tSirEXTScanSetSsidHotListReqParams *wdaRequest)
19363{
19364 WDI_Status status = WDI_STATUS_SUCCESS;
19365 tWDA_ReqParams *pWdaParams;
19366
19367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19368 "%s: ", __func__);
19369 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19370 if (NULL == pWdaParams)
19371 {
19372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19373 "%s: VOS MEM Alloc Failure", __func__);
19374 VOS_ASSERT(0);
19375 return VOS_STATUS_E_NOMEM;
19376 }
19377 pWdaParams->pWdaContext = pWDA;
19378 pWdaParams->wdaMsgParam = wdaRequest;
19379 pWdaParams->wdaWdiApiMsgParam = NULL;
19380
19381 status = WDI_EXTScanSetSSIDHotlistReq((void *)wdaRequest,
19382 (WDI_EXTScanSetSSIDHotlistRspCb)WDA_EXTScanSetSSIDHotlistRspCallback,
19383 (void *)pWdaParams);
19384 if (IS_WDI_STATUS_FAILURE(status))
19385 {
19386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19387 "Failure to request. Free all the memory " );
19388 vos_mem_free(pWdaParams->wdaMsgParam);
19389 vos_mem_free(pWdaParams);
19390 }
19391 return CONVERT_WDI2VOS_STATUS(status);
19392}
19393
19394/*==========================================================================
19395 FUNCTION WDA_ProcessEXTScanReSetSSIDHotlistReq
19396
19397 DESCRIPTION
19398 API to send Reset SSID Hotlist Request to WDI
19399
19400 PARAMETERS
19401 pWDA: Pointer to WDA context
19402 wdaRequest: Pointer to EXTScan req parameters
19403===========================================================================*/
19404VOS_STATUS WDA_ProcessEXTScanResetSSIDHotlistReq(tWDA_CbContext *pWDA,
19405 tSirEXTScanResetSsidHotlistReqParams *wdaRequest)
19406{
19407 WDI_Status status = WDI_STATUS_SUCCESS;
19408 tWDA_ReqParams *pWdaParams;
19409
19410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19411 "%s:", __func__);
19412 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19413 if (NULL == pWdaParams)
19414 {
19415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19416 "%s: VOS MEM Alloc Failure", __func__);
19417 VOS_ASSERT(0);
19418 return VOS_STATUS_E_NOMEM;
19419 }
19420 pWdaParams->pWdaContext = pWDA;
19421 pWdaParams->wdaMsgParam = wdaRequest;
19422 pWdaParams->wdaWdiApiMsgParam = NULL;
19423
19424 status = WDI_EXTScanResetSSIDHotlistReq((void *)wdaRequest,
19425 (WDI_EXTScanResetSSIDHotlistRspCb)WDA_EXTScanResetSSIDHotlistRspCallback,
19426 (void *)pWdaParams);
19427 if (IS_WDI_STATUS_FAILURE(status))
19428 {
19429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19430 "Failure to request. Free all the memory " );
19431 vos_mem_free(pWdaParams->wdaMsgParam);
19432 vos_mem_free(pWdaParams);
19433 }
19434 return CONVERT_WDI2VOS_STATUS(status);
19435}
19436
19437
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]19438#endif /* WLAN_FEATURE_EXTSCAN */
19439
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]19440#ifdef WLAN_FEATURE_LINK_LAYER_STATS
19441
19442/*==========================================================================
19443 FUNCTION WDA_LLStatsSetRspCallback
19444
19445 DESCRIPTION
19446 API to process set link layer statistics response from FW
19447
19448 PARAMETERS
19449 pRsp: Pointer to set link layer statistics response
19450 pUserData: Pointer to user data
19451
19452 RETURN VALUE
19453 NONE
19454
19455===========================================================================*/
19456void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
19457{
19458 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19459
19460
19461 if (NULL == pWdaParams)
19462 {
19463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19464 "%s: pWdaParams received NULL", __func__);
19465 VOS_ASSERT(0) ;
19466 return ;
19467 }
19468
19469 /* Do not need to send notification to upper layer
19470 * Just free allocated resources */
19471 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19472 {
19473 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19474 }
19475 if (pWdaParams->wdaMsgParam != NULL)
19476 {
19477 vos_mem_free(pWdaParams->wdaMsgParam);
19478 }
19479 vos_mem_free(pWdaParams) ;
19480
19481 return;
19482}
19483
19484/*==========================================================================
19485 FUNCTION WDA_ProcessLLStatsSetReq
19486
19487 DESCRIPTION
19488 API to send Set Link Layer Stats request to WDI
19489
19490 PARAMETERS
19491 pWDA: Pointer to WDA context
19492 wdaRequest: Pointer to set Link Layer Stats req parameters
19493===========================================================================*/
19494VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
19495 tSirLLStatsSetReq *wdaRequest)
19496{
19497 WDI_Status status = WDI_STATUS_SUCCESS;
19498 tWDA_ReqParams *pWdaParams;
19499
19500 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19501 if (NULL == pWdaParams)
19502 {
19503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19504 "%s: VOS MEM Alloc Failure", __func__);
19505 VOS_ASSERT(0);
19506 return VOS_STATUS_E_NOMEM;
19507 }
19508 pWdaParams->pWdaContext = pWDA;
19509 pWdaParams->wdaMsgParam = wdaRequest;
19510 pWdaParams->wdaWdiApiMsgParam = NULL;
19511
19512 status = WDI_LLStatsSetReq((void *)wdaRequest,
19513 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
19514 (void *)pWdaParams);
19515 if (IS_WDI_STATUS_FAILURE(status))
19516 {
19517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19518 "Failure to request. Free all the memory " );
19519 vos_mem_free(pWdaParams->wdaMsgParam);
19520 vos_mem_free(pWdaParams);
19521 }
19522 return CONVERT_WDI2VOS_STATUS(status);
19523}
19524
19525/*==========================================================================
19526 FUNCTION WDA_LLStatsGetRspCallback
19527
19528 DESCRIPTION
19529 API to process get link layer statistics response from FW
19530
19531 PARAMETERS
19532 pRsp: Pointer to get link layer statistics response
19533 pUserData: Pointer to user data
19534
19535 RETURN VALUE
19536 NONE
19537
19538===========================================================================*/
19539void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
19540{
19541 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19542
19543 if (NULL == pWdaParams)
19544 {
19545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19546 "%s: pWdaParams received NULL", __func__);
19547 VOS_ASSERT(0) ;
19548 return ;
19549 }
19550
19551 /* Do not need to send notification to upper layer
19552 * Just free allocated resources */
19553 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19554 {
19555 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19556 }
19557 if (pWdaParams->wdaMsgParam != NULL)
19558 {
19559 vos_mem_free(pWdaParams->wdaMsgParam);
19560 }
19561 vos_mem_free(pWdaParams) ;
19562
19563 return;
19564}
19565
19566/*==========================================================================
19567 FUNCTION WDA_ProcessLLStatsGetReq
19568
19569 DESCRIPTION
19570 API to send Get Link Layer Stats request to WDI
19571
19572 PARAMETERS
19573 pWDA: Pointer to WDA context
19574 wdaRequest: Pointer to get Link Layer Stats req parameters
19575===========================================================================*/
19576VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
19577 tSirLLStatsGetReq *wdaRequest)
19578{
19579 WDI_Status status = WDI_STATUS_SUCCESS;
19580 tWDA_ReqParams *pWdaParams;
19581
19582 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19583 if (NULL == pWdaParams)
19584 {
19585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19586 "%s: VOS MEM Alloc Failure", __func__);
19587 VOS_ASSERT(0);
19588 return VOS_STATUS_E_NOMEM;
19589 }
19590 pWdaParams->pWdaContext = pWDA;
19591 pWdaParams->wdaMsgParam = wdaRequest;
19592 pWdaParams->wdaWdiApiMsgParam = NULL;
19593
19594 status = WDI_LLStatsGetReq((void *) wdaRequest,
19595 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
19596 (void *)pWdaParams);
19597 if (IS_WDI_STATUS_FAILURE(status))
19598 {
19599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19600 "Failure to request. Free all the memory " );
19601 vos_mem_free(pWdaParams->wdaMsgParam);
19602 vos_mem_free(pWdaParams);
19603 }
19604 return CONVERT_WDI2VOS_STATUS(status);
19605}
19606
19607/*==========================================================================
19608 FUNCTION WDA_LLStatsClearRspCallback
19609
19610 DESCRIPTION
19611 API to process clear link layer statistics response from FW
19612
19613 PARAMETERS
19614 pRsp: Pointer to clear link layer statistics response
19615 pUserData: Pointer to user data
19616
19617 RETURN VALUE
19618 NONE
19619
19620===========================================================================*/
19621void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
19622{
19623 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19624
19625
19626 if (NULL == pWdaParams)
19627 {
19628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19629 "%s: pWdaParams received NULL", __func__);
19630 VOS_ASSERT(0) ;
19631 return ;
19632 }
19633 /* Do not need to send notification to upper layer
19634 * Just free allocated resources */
19635 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19636 {
19637 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19638 }
19639 if (pWdaParams->wdaMsgParam != NULL)
19640 {
19641 vos_mem_free(pWdaParams->wdaMsgParam);
19642 }
19643 vos_mem_free(pWdaParams) ;
19644 return;
19645}
19646
19647/*==========================================================================
19648 FUNCTION WDA_ProcessLLStatsClearReq
19649
19650 DESCRIPTION
19651 API to send Clear Link Layer Stats request to WDI
19652
19653 PARAMETERS
19654 pWDA: Pointer to WDA context
19655 wdaRequest: Pointer to earLink Layer Stats req
19656===========================================================================*/
19657VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
19658 tSirLLStatsClearReq *wdaRequest)
19659{
19660 WDI_Status status = WDI_STATUS_SUCCESS;
19661 tWDA_ReqParams *pWdaParams;
19662
19663 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19664 if (NULL == pWdaParams)
19665 {
19666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19667 "%s: VOS MEM Alloc Failure", __func__);
19668 VOS_ASSERT(0);
19669 return VOS_STATUS_E_NOMEM;
19670 }
19671 pWdaParams->pWdaContext = pWDA;
19672 pWdaParams->wdaMsgParam = wdaRequest;
19673 pWdaParams->wdaWdiApiMsgParam = NULL;
19674
19675 status = WDI_LLStatsClearReq((void *) wdaRequest,
19676 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
19677 (void *)pWdaParams);
19678 if (IS_WDI_STATUS_FAILURE(status))
19679 {
19680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19681 "Failure to request. Free all the memory " );
19682 vos_mem_free(pWdaParams->wdaMsgParam);
19683 vos_mem_free(pWdaParams);
19684 }
19685 return CONVERT_WDI2VOS_STATUS(status);
19686}
19687
19688#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]19689
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]19690void WDA_FWStatsGetRspCallback(WDI_Status status,void *fwStatsResp,void *pUserData)
19691{
19692 tSirFWStatsInfo *fwStatsinfo = (tSirFWStatsInfo *)pUserData;
19693
19694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19695 "<------ %s " ,__func__);
19696 if (NULL == fwStatsinfo)
19697 {
19698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19699 "%s: pWdaParams received NULL", __func__);
19700 VOS_ASSERT(0);
19701 return;
19702 }
19703
19704 if(fwStatsinfo->callback)
19705 fwStatsinfo->callback(status, fwStatsResp, fwStatsinfo->data);
19706
19707 vos_mem_free(pUserData);
19708 return;
19709}
19710
19711
19712v_VOID_t WDA_ProcessFWStatsGetReq(tWDA_CbContext *pWDA,
19713 tSirFWStatsGetReq *pData)
19714{
19715
19716 WDI_Status wdiStatus;
19717 tSirFWStatsInfo *fwStatsinfo;
19718
19719 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19720 "------> %s" , __func__);
19721
19722 fwStatsinfo =
19723 (tSirFWStatsInfo *)vos_mem_malloc(sizeof(tSirFWStatsInfo));
19724 if (NULL == fwStatsinfo)
19725 {
19726 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19727 "%s: VOS MEM Alloc Failure", __func__);
19728 VOS_ASSERT(0);
19729 vos_mem_free(pData);
19730 return;
19731 }
19732
19733 fwStatsinfo->callback = (tSirFWStatsCallback)(pData->callback);
19734 fwStatsinfo->data = pData->data;
19735
19736 wdiStatus = WDI_FWStatsGetReq(fwStatsinfo,
19737 WDA_FWStatsGetRspCallback,
19738 pData->stats);
19739 if (WDI_STATUS_PENDING == wdiStatus)
19740 {
19741 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19742 "Pending received for %s:%d ", __func__, __LINE__);
19743 }
19744 else if (WDI_STATUS_SUCCESS != wdiStatus)
19745 {
19746 if (fwStatsinfo->callback)
19747 {
19748 fwStatsinfo->callback(WDI_STATUS_E_FAILURE, NULL ,fwStatsinfo->data);
19749 }
19750 vos_mem_free(fwStatsinfo);
19751 }
19752 vos_mem_free(pData);
19753}
19754
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]19755/*==========================================================================
19756 FUNCTION WDA_EncryptMsgRspCallback
19757
19758 DESCRIPTION
19759 API to send Encrypt message response to HDD
19760
19761 PARAMETERS
19762 pEventData: Response from FW
19763 pUserData: Data sent to firmware as part of request
19764===========================================================================*/
19765void WDA_EncryptMsgRspCallback(WDI_Status status, void *pEventData,
19766 void* pUserData)
19767{
19768 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19769 tWDA_CbContext *pWDA = NULL;
19770 tpAniSirGlobal pMac;
19771 vos_msg_t vosMsg;
19772 tpSirEncryptedDataRspParams pEncRspParams;
19773 tpSetEncryptedDataRspParams pEncryptedDataRsp;
19774
19775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19776 FL("%s:"), __func__);
19777 if (NULL == pWdaParams)
19778 {
19779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19780 FL("%s: pWdaParams received NULL"), __func__);
19781 VOS_ASSERT(0);
19782 return;
19783 }
19784
19785 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19786
19787 if (NULL == pWDA)
19788 {
19789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19790 FL("%s: pWDA received NULL"), __func__);
19791 VOS_ASSERT(0);
19792 goto error;
19793 }
19794
19795 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19796 if (NULL == pMac)
19797 {
19798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19799 FL("%s:pMac is NULL"), __func__);
19800 VOS_ASSERT(0);
19801 goto error;
19802 }
19803
19804 pEncryptedDataRsp = (tpSetEncryptedDataRspParams) pEventData;
19805
19806 pEncRspParams = vos_mem_malloc(sizeof(tSirEncryptedDataRspParams));
19807 if (NULL == pEncRspParams)
19808 {
19809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19810 FL("%s: VOS MEM Alloc Failure"), __func__);
19811 VOS_ASSERT(0);
19812 goto error;
19813 }
19814
19815 /* Message Header */
19816 pEncRspParams->mesgType = eWNI_SME_ENCRYPT_MSG_RSP;
19817 pEncRspParams->mesgLen = sizeof(tSirEncryptedDataRspParams);
19818 pEncRspParams->encryptedDataRsp.encryptedPayload.length =
19819 pEncryptedDataRsp->encryptedPayload.length;
19820 vos_mem_copy(pEncRspParams->encryptedDataRsp.encryptedPayload.data,
19821 pEncryptedDataRsp->encryptedPayload.data,
19822 pEncryptedDataRsp->encryptedPayload.length);
19823
19824 /* VOS message wrapper */
19825 vosMsg.type = eWNI_SME_ENCRYPT_MSG_RSP;
19826 vosMsg.bodyptr = (void *)pEncRspParams;
19827 vosMsg.bodyval = 0;
19828
19829 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
19830 {
19831 /* free the mem */
19832 vos_mem_free((v_VOID_t *) pEncRspParams);
19833 }
19834
19835error:
19836
19837 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19838 {
19839 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19840 }
19841 if (pWdaParams->wdaMsgParam != NULL)
19842 {
19843 vos_mem_free(pWdaParams->wdaMsgParam);
19844 }
19845 vos_mem_free(pWdaParams) ;
19846
19847 return;
19848}
19849/*==========================================================================
19850 FUNCTION WDA_ProcessEncryptMsgReq
19851
19852 DESCRIPTION
19853 API to send Encrypt message Request to WDI
19854
19855 PARAMETERS
19856 pWDA: Pointer to WDA context
19857 wdaRequest: Pointer to Encrypt_msg req parameters
19858===========================================================================*/
19859VOS_STATUS WDA_ProcessEncryptMsgReq(tWDA_CbContext *pWDA,
19860 u8 *wdaRequest)
19861{
19862 WDI_Status status = WDI_STATUS_SUCCESS;
19863 tWDA_ReqParams *pWdaParams;
19864
19865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19866 FL("%s: "), __func__);
19867 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19868 if (NULL == pWdaParams)
19869 {
19870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19871 FL("%s: VOS MEM Alloc Failure"), __func__);
19872 VOS_ASSERT(0);
19873 return VOS_STATUS_E_NOMEM;
19874 }
19875 pWdaParams->pWdaContext = pWDA;
19876 pWdaParams->wdaMsgParam = wdaRequest;
19877 pWdaParams->wdaWdiApiMsgParam = NULL;
19878
19879 status = WDI_EncryptMsgReq((void *)wdaRequest,
19880 (WDI_EncryptMsgRspCb)WDA_EncryptMsgRspCallback,
19881 (void *)pWdaParams);
19882 if (IS_WDI_STATUS_FAILURE(status))
19883 {
19884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19885 FL("Failure to request. Free all the memory " ));
19886 vos_mem_free(pWdaParams->wdaMsgParam);
19887 vos_mem_free(pWdaParams);
19888 }
19889 return CONVERT_WDI2VOS_STATUS(status);
19890}
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]19891/*==========================================================================
19892 FUNCTION WDA_ProcessSetRtsCtsHTVhtInd
19893
19894 DESCRIPTION
19895 API to enable/disable RTS/CTS for different modes.
19896
19897 PARAMETERS
19898 pWDA: Pointer to WDA context
19899 rtsCtsVal : Bit mask value to enable RTS/CTS for different modes
19900===========================================================================*/
19901
19902VOS_STATUS
19903WDA_ProcessSetRtsCtsHTVhtInd(tWDA_CbContext *pWDA,
19904 tANI_U32 rtsCtsVal)
19905{
19906 WDI_Status status;
19907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19908 FL("---> %s"), __func__);
19909 status = WDI_SetRtsCtsHTVhtInd(rtsCtsVal);
19910 if (WDI_STATUS_PENDING == status)
19911 {
19912 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19913 FL("pending status received "));
19914 }
19915 else if (WDI_STATUS_SUCCESS_SYNC != status)
19916 {
19917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19918 FL("Failure status %d"), status);
19919 }
19920 return CONVERT_WDI2VOS_STATUS(status) ;
19921}
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19922
19923void WDA_MonModeRspCallback(void *pEventData, void* pUserData)
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19924{
19925 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19926 tSirMonModeReq *pData;
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19927
19928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19929 "<------ %s " ,__func__);
19930 if (NULL == pWdaParams)
19931 {
19932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19933 "%s: pWdaParams received NULL", __func__);
19934 VOS_ASSERT(0) ;
19935 return ;
19936 }
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19937 pData = (tSirMonModeReq *)pWdaParams->wdaMsgParam;
19938 if (pData != NULL) {
19939 pData->callback(pData->magic, pData->cmpVar);
19940 vos_mem_free(pWdaParams->wdaMsgParam);
19941 }
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19942 vos_mem_free(pWdaParams) ;
19943
19944 return;
19945}
19946
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19947VOS_STATUS WDA_ProcessMonStartReq( tWDA_CbContext *pWDA, void *wdaRequest)
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19948{
19949
19950 WDI_Status status = WDI_STATUS_SUCCESS;
19951 tWDA_ReqParams *pWdaParams;
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19952 tSirMonModeReq *pMonModeData = (tSirMonModeReq *)wdaRequest;
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19953
19954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19955 FL("%s: "), __func__);
19956 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19957 if (NULL == pWdaParams)
19958 {
19959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19960 FL("%s: VOS MEM Alloc Failure"), __func__);
19961 VOS_ASSERT(0);
19962 return VOS_STATUS_E_NOMEM;
19963 }
19964 pWdaParams->pWdaContext = pWDA;
19965 pWdaParams->wdaMsgParam = wdaRequest;
19966 pWdaParams->wdaWdiApiMsgParam = NULL;
19967
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]19968 status = WDI_MonStartReq(pMonModeData->data,
19969 (WDI_MonModeRspCb)WDA_MonModeRspCallback,
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19970 (void *)pWdaParams);
19971 if (IS_WDI_STATUS_FAILURE(status))
19972 {
19973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19974 "Failure to request. Free all the memory " );
19975 vos_mem_free(pWdaParams->wdaMsgParam);
19976 vos_mem_free(pWdaParams);
19977 }
19978 return CONVERT_WDI2VOS_STATUS(status);
19979}
19980
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]19981VOS_STATUS WDA_ProcessMonStopReq( tWDA_CbContext *pWDA, void* wdaRequest)
19982{
19983
19984 WDI_Status status = WDI_STATUS_SUCCESS;
19985 tWDA_ReqParams *pWdaParams;
19986
19987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19988 FL("%s: "), __func__);
19989 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19990 if (NULL == pWdaParams)
19991 {
19992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19993 FL("%s: VOS MEM Alloc Failure"), __func__);
19994 VOS_ASSERT(0);
19995 return VOS_STATUS_E_NOMEM;
19996 }
19997 pWdaParams->pWdaContext = pWDA;
19998 pWdaParams->wdaMsgParam = wdaRequest;
19999 pWdaParams->wdaWdiApiMsgParam = NULL;
20000
Bhargav Shah1ae5de02015-07-20 13:32:31 +0530[diff] [blame]20001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20002 "%s: Processing Mon stop request", __func__);
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20003 status = WDI_MonStopReq((WDI_MonModeRspCb)WDA_MonModeRspCallback,
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20004 (void *)pWdaParams);
20005
20006 if (IS_WDI_STATUS_FAILURE(status))
20007 {
20008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20009 "Failure to request. Free all the memory " );
20010 vos_mem_free(pWdaParams->wdaMsgParam);
20011 vos_mem_free(pWdaParams);
20012 }
20013 return CONVERT_WDI2VOS_STATUS(status);
20014}
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]20015
20016VOS_STATUS WDA_ProcessEnableDisableCAEventInd(tWDA_CbContext *pWDA, tANI_U8 val)
20017{
20018 WDI_Status status;
20019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20020 FL("---> %s"), __func__);
20021 status = WDI_EnableDisableCAEventInd(val);
20022 if (WDI_STATUS_PENDING == status)
20023 {
20024 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20025 FL("pending status received "));
20026 }
20027 else if (WDI_STATUS_SUCCESS_SYNC != status)
20028 {
20029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20030 FL("Failure status %d"), status);
20031 }
20032 return CONVERT_WDI2VOS_STATUS(status) ;
20033}