Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 0644e48761143369e7574d26c4792d9c7476dd7f / . / CORE / WDA / src / wlan_qct_wda.c
blob: 89165bbcad2487503ddab7887e9ee402a0f87aec [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]2 * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]26 */
27
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]28
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]29
30
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]35 The functions externalized by this module are to be called ONLY by other
36 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]38 Are listed for each API below.
39
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]40 Copyright (c) 2010-2011 QUALCOMM Incorporated.
41 All Rights Reserved.
42 Qualcomm Confidential and Proprietary
43===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]45 EDIT HISTORY FOR FILE
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 This section contains comments describing changes made to the module.
48 Notice that changes are listed in reverse chronological order.
49
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]50 $Header$$DateTime$$Author$
51
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]52 when who what, where, why
53---------- --- -------------------------------------------------
5410/05/2011 haparna Adding support for Keep Alive Feature
552010-12-30 smiryala UMAC convergence changes
562010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
57===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]58#include "vos_mq.h"
59#include "vos_api.h"
60#include "vos_packet.h"
61#include "vos_nvitem.h"
62#include "sirApi.h"
63#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]64#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]65#include "wlan_qct_wda.h"
66#include "wlan_qct_wda_msg.h"
67#include "wlan_qct_wdi_cfg.h"
68#include "wlan_qct_wdi.h"
69#include "wlan_qct_wdi_ds.h"
70#include "wlan_hal_cfg.h"
71/**********************/
72#include "wniApi.h"
73#include "cfgApi.h"
74#include "limApi.h"
75#include "wlan_qct_tl.h"
76#include "wlan_qct_tli_ba.h"
77#include "limUtils.h"
78#include "btcApi.h"
79#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]80#include "pttMsgApi.h"
81#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82/* Used MACRO's */
83/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]84#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
86#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]88#define CONVERT_WDI2SIR_STATUS(x) \
89 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
90
91#define IS_WDI_STATUS_FAILURE(status) \
92 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]93#define CONVERT_WDI2VOS_STATUS(x) \
94 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
95
96/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]97#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#define WDA_TL_GET_TX_PKTCOUNT(a, b, c, d) WLANTL_GetTxPktCount(a, b, c, d)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]99#define WDA_GET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
101
102#define WDA_SET_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
104
105#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
106 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]107#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
108 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]109/* timer related Macros */
110#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
111 tx_timer_create(a, b, c, d, e, f, g)
112#define WDA_START_TIMER(a) tx_timer_activate(a)
113#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
114#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]115#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116
117#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
118 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]122#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]123#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]125#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]127#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]128#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
129 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
130 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
131
132#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
133#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]134#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]136/* extern declarations */
137extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]138extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* forward declarations */
141void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
142 void *pBodyptr, tANI_U32 bodyVal) ;
143VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
144 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]145VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
146VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
147
148extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
149 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]150void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]151void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
152 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
153void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
154 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
155void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
156 void* pUserData ) ;
157static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
158static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
159void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]160void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]162#ifdef WLAN_FEATURE_VOWIFI_11R
163VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
164#endif /* WLAN_FEATURE_VOWIFI_11R */
165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
167void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
168VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]169#ifdef FEATURE_WLAN_SCAN_PNO
170static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
171static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
172static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
173#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]174#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]175VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]176void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
177void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
178void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
179#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]180#ifdef WLAN_FEATURE_PACKET_FILTERING
181static VOS_STATUS WDA_Process8023MulticastListReq (
182 tWDA_CbContext *pWDA,
183 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
184 );
185static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
188 );
189static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
190 tWDA_CbContext *pWDA,
191 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
192 );
193static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
194 tWDA_CbContext *pWDA,
195 tSirRcvFltPktClearParam *pRcvFltPktClearParam
196 );
197#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]199static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
200 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]201VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
202 v_U8_t *pDefaultKeyId,
203 v_U8_t *pNumKeys,
204 WDI_KeysType *pWdiKeys );
205
206#ifdef WLAN_FEATURE_GTK_OFFLOAD
207static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
208static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
209#endif // WLAN_FEATURE_GTK_OFFLOAD
210
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]211v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
212 tSirBcnMissRateReq *pData);
213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]214VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
215 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]216#ifdef WLAN_FEATURE_11AC
217VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
218 tUpdateVHTOpMode *pData);
219#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]220
221#ifdef FEATURE_WLAN_LPHB
222VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
223 tSirLPHBReq *pData);
224#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]225
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]226#ifdef WLAN_FEATURE_EXTSCAN
227VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
228 tSirEXTScanStartReqParams *wdaRequest);
229VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
230 tSirEXTScanStopReqParams *wdaRequest);
231VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
232 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
234 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
236 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
238 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
243#endif /* WLAN_FEATURE_EXTSCAN */
244
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]245#ifdef WLAN_FEATURE_LINK_LAYER_STATS
246VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
247 tSirLLStatsSetReq *wdaRequest);
248
249VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
250 tSirLLStatsGetReq *wdaRequest);
251
252VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
253 tSirLLStatsClearReq *wdaRequest);
254#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]255/*
256 * FUNCTION: WDA_open
257 * Allocate the WDA context
258 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]259VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]260 tMacOpenParameters *pMacParams )
261{
262 tWDA_CbContext *wdaContext;
263 VOS_STATUS status;
264 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]265 /* Allocate WDA context */
266 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
267 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
268 if(!VOS_IS_STATUS_SUCCESS(status))
269 {
270 return VOS_STATUS_E_NOMEM;
271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]272 /*__asm int 3;*/
273 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
274
275 /* Initialize data structures */
276 wdaContext->pVosContext = pVosContext;
277 wdaContext->wdaState = WDA_INIT_STATE;
278 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
279
280 /* Initialize WDA-WDI synchronization event */
281 status = vos_event_init(&wdaContext->wdaWdiEvent);
282 if(!VOS_IS_STATUS_SUCCESS(status))
283 {
284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]285 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]286 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]288 /* Init Frame transfer event */
289 status = vos_event_init(&wdaContext->txFrameEvent);
290 if(!VOS_IS_STATUS_SUCCESS(status))
291 {
292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]293 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]294 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]296 status = vos_event_init(&wdaContext->suspendDataTxEvent);
297 if(!VOS_IS_STATUS_SUCCESS(status))
298 {
299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]300 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]301 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]303 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
304 if(!VOS_IS_STATUS_SUCCESS(status))
305 {
306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]307 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]308 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]311 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]312 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]313 &wdiDevCapability, pMacParams->driverType))
314 {
315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
316 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]317 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]318 }
319 else
320 {
321 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
322 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
323 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]324 /* update max STA in WDA used for BA */
325 wdaContext->wdaMaxSta = pMacParams->maxStation;
326 /* store the frameTransRequired flag in wdaContext, to send this to HAL
327 * in WDA_Start
328 */
329 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]331 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]332
333error:
334 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
335 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336}
337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]338/*
339 * FUNCTION: WDA_preStart
340 * Trigger DAL-AL to start CFG download
341 */
342VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
343{
344 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
345 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /*
347 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
348 */
349 wdaMsg.type = WNI_CFG_DNLD_REQ ;
350 wdaMsg.bodyptr = NULL;
351 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]352 /* post the message.. */
353 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
354 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
355 {
356 vosStatus = VOS_STATUS_E_BADMSG;
357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]358 return( vosStatus );
359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]360/*
361 * FUNCTION: WDA_wdiStartCallback
362 * Once WDI_Start is finished, WDI start callback will be called by WDI
363 * to indicate completion of WDI_Start.
364 */
365void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
366 void *pVosContext)
367{
368 tWDA_CbContext *wdaContext;
369 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 if (NULL == pVosContext)
371 {
372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]373 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]374 return;
375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]376 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
377 if (NULL == wdaContext)
378 {
379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]380 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]381 return;
382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]383 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
384 {
385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]386 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]387 }
388 else
389 {
390 wdaContext->wdaState = WDA_START_STATE;
391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 /* extract and save version information from the Start Response */
393 wdaContext->wcnssWlanCompiledVersion.major =
394 wdiRspParams->wlanCompiledVersion.major;
395 wdaContext->wcnssWlanCompiledVersion.minor =
396 wdiRspParams->wlanCompiledVersion.minor;
397 wdaContext->wcnssWlanCompiledVersion.version =
398 wdiRspParams->wlanCompiledVersion.version;
399 wdaContext->wcnssWlanCompiledVersion.revision =
400 wdiRspParams->wlanCompiledVersion.revision;
401 wdaContext->wcnssWlanReportedVersion.major =
402 wdiRspParams->wlanReportedVersion.major;
403 wdaContext->wcnssWlanReportedVersion.minor =
404 wdiRspParams->wlanReportedVersion.minor;
405 wdaContext->wcnssWlanReportedVersion.version =
406 wdiRspParams->wlanReportedVersion.version;
407 wdaContext->wcnssWlanReportedVersion.revision =
408 wdiRspParams->wlanReportedVersion.revision;
409 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
410 wdiRspParams->wcnssSoftwareVersion,
411 sizeof(wdaContext->wcnssSoftwareVersionString));
412 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
413 wdiRspParams->wcnssHardwareVersion,
414 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]415 /* Notify WDA_start that WDI_Start has completed */
416 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]417 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]418 {
419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]420 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]422 return;
423}
424
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]425/*
426 * FUNCTION: WDA_start
427 * Prepare TLV configuration and call WDI_Start.
428 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429VOS_STATUS WDA_start(v_PVOID_t pVosContext)
430{
431 tWDA_CbContext *wdaContext;
432 VOS_STATUS status;
433 WDI_Status wdiStatus;
434 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 if (NULL == pVosContext)
436 {
437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]438 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]439 return VOS_STATUS_E_FAILURE;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
442 if (NULL == wdaContext)
443 {
444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]445 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]446 return VOS_STATUS_E_FAILURE;
447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]448 /* Non-FTM mode, WDA status for START must be INIT
449 * FTM mode, WDA Status for START can be INIT or STOP */
450 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
451 (WDA_STOP_STATE != wdaContext->wdaState) )
452 {
453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
454 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]455 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]456 return VOS_STATUS_E_FAILURE;
457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 /* initialize the wdiStartParam. Note that we can create this on
459 the stack since we won't exit until WDI_Start() completes or
460 times out */
461 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]463 /* prepare the config TLV for the WDI */
464 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
465 if ( !VOS_IS_STATUS_SUCCESS(status) )
466 {
467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]468 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]469 return VOS_STATUS_E_FAILURE;
470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]471 /* note from here onwards if an error occurs we must
472 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]473 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
474 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
475 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]476 /* initialize the WDA-WDI synchronization event */
477 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]478 /* call WDI start */
479 wdiStatus = WDI_Start(&wdiStartParam,
480 (WDI_StartRspCb)WDA_wdiStartCallback,
481 (v_VOID_t *)pVosContext);
482 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
483 {
484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]485 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]486 vos_mem_free(wdiStartParam.pConfigBuffer);
487 return VOS_STATUS_E_FAILURE;
488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /* wait for WDI start to invoke our callback */
490 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
491 WDA_WDI_START_TIMEOUT );
492 if ( !VOS_IS_STATUS_SUCCESS(status) )
493 {
494 if ( VOS_STATUS_E_TIMEOUT == status )
495 {
496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]497 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 }
499 else
500 {
501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
502 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
505 vos_mem_free(wdiStartParam.pConfigBuffer);
506 return VOS_STATUS_E_FAILURE;
507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]509 /* we no longer need the config TLV */
510 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]511 /* if we are not in the START state then WDI_Start() failed */
512 if (WDA_START_STATE != wdaContext->wdaState)
513 {
514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]515 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]516 return VOS_STATUS_E_FAILURE;
517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 /* FTM mode does not need to monitor BA activity */
519 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
520 {
521 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]522 if(VOS_STATUS_SUCCESS == status)
523 {
524 wdaContext->wdaTimersCreated = VOS_TRUE;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]527 else
528 {
529 vos_event_init(&wdaContext->ftmStopDoneEvent);
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 return status;
532}
533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]534/*
535 * FUNCTION: WDA_prepareConfigTLV
536 * Function to prepare CFG for DAL(WDA)
537 */
538VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
539 WDI_StartReqParamsType *wdiStartParams )
540{
541 /* get pMac to acess CFG data base */
542 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
543 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
544 tHalCfg *tlvStruct = NULL ;
545 tANI_U8 *tlvStructStart = NULL ;
546 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
547 v_PVOID_t *configParam;
548 tANI_U32 configParamSize;
549 tANI_U32 *configDataValue;
550 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]551 tANI_U8 i;
552
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]553 if ((NULL == pMac)||(NULL == wdaContext))
554 {
555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]556 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]557 VOS_ASSERT(0);
558 return VOS_STATUS_E_FAILURE;
559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]560 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
561 WNI_CFG_STA_ID_LEN +
562 WNI_CFG_EDCA_WME_ACBK_LEN +
563 WNI_CFG_EDCA_WME_ACBE_LEN +
564 WNI_CFG_EDCA_WME_ACVI_LEN +
565 WNI_CFG_EDCA_WME_ACVO_LEN +
566 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]567 /* malloc memory for all configs in one shot */
568 configParam = vos_mem_malloc(configParamSize);
569
570 if(NULL == configParam )
571 {
572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]573 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]574 VOS_ASSERT(0) ;
575 return VOS_STATUS_E_NOMEM;
576 }
577 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]579 tlvStruct = (tHalCfg *)configParam;
580 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 /* TODO: Remove Later */
582 /* QWLAN_HAL_CFG_STA_ID */
583 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
584 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
585 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
586 eSIR_SUCCESS)
587 {
588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
589 "Failed to get value for WNI_CFG_STA_ID");
590 goto handle_failure;
591 }
592 tlvStruct->length = strLength ;
593 /* calculate the pad bytes to have the CFG in aligned format */
594 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
595 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]596 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
597 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]598 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
599 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
600 tlvStruct->length = sizeof(tANI_U32);
601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
602 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
603 != eSIR_SUCCESS)
604 {
605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
606 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
607 goto handle_failure;
608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]611 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
612 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
613 tlvStruct->length = sizeof(tANI_U32);
614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
615 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
616 eSIR_SUCCESS)
617 {
618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
619 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
620 goto handle_failure;
621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
623 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]624 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
625 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
626 tlvStruct->length = sizeof(tANI_U32);
627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
628 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
629 != eSIR_SUCCESS)
630 {
631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
632 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
633 goto handle_failure;
634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]635 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
636 + sizeof(tHalCfg) + tlvStruct->length)) ;
637
638 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
639 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
640 tlvStruct->length = sizeof(tANI_U32);
641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
642 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
643 configDataValue ) != eSIR_SUCCESS)
644 {
645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
646 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
647 goto handle_failure;
648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]649 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
650 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* QWLAN_HAL_CFG_CAL_PERIOD */
652 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
653 tlvStruct->length = sizeof(tANI_U32);
654 configDataValue = (tANI_U32 *)(tlvStruct + 1);
655 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
656 != eSIR_SUCCESS)
657 {
658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
659 "Failed to get value for WNI_CFG_CAL_PERIOD");
660 goto handle_failure;
661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
663 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]664 /* QWLAN_HAL_CFG_CAL_CONTROL */
665 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
666 tlvStruct->length = sizeof(tANI_U32);
667 configDataValue = (tANI_U32 *)(tlvStruct + 1);
668 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
669 != eSIR_SUCCESS)
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 "Failed to get value for WNI_CFG_CAL_CONTROL");
673 goto handle_failure;
674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]675 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
676 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]677 /* QWLAN_HAL_CFG_PROXIMITY */
678 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
679 tlvStruct->length = sizeof(tANI_U32);
680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
681 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
682 != eSIR_SUCCESS)
683 {
684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
685 "Failed to get value for WNI_CFG_PROXIMITY");
686 goto handle_failure;
687 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]688 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
689 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]690 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
691 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
692 tlvStruct->length = sizeof(tANI_U32);
693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
694 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
695 != eSIR_SUCCESS)
696 {
697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
698 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
699 goto handle_failure;
700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
702 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]703 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
704 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
705 tlvStruct->length = sizeof(tANI_U32);
706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
707 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
708 eSIR_SUCCESS)
709 {
710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
711 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
712 goto handle_failure;
713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]714 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
715 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]716 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
717 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
718 tlvStruct->length = sizeof(tANI_U32);
719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
720 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
721 configDataValue ) != eSIR_SUCCESS)
722 {
723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
724 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
725 goto handle_failure;
726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
728 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
730 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
731 tlvStruct->length = sizeof(tANI_U32);
732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
733 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
738 goto handle_failure;
739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]740 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
741 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]742 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
743 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
744 tlvStruct->length = sizeof(tANI_U32);
745 configDataValue = (tANI_U32 *)(tlvStruct + 1);
746 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
747 eSIR_SUCCESS)
748 {
749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
750 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
751 goto handle_failure;
752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]755 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
756 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
757 tlvStruct->length = sizeof(tANI_U32);
758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
759 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
760 eSIR_SUCCESS)
761 {
762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
763 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
764 goto handle_failure;
765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]766 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
767 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]768 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
769 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
770 tlvStruct->length = sizeof(tANI_U32);
771 configDataValue = (tANI_U32 *)(tlvStruct + 1);
772 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
773 configDataValue ) != eSIR_SUCCESS)
774 {
775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
776 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
777 goto handle_failure;
778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]779 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
780 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]781 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
782 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
783 tlvStruct->length = sizeof(tANI_U32);
784 configDataValue = (tANI_U32 *)(tlvStruct + 1);
785 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
786 configDataValue ) != eSIR_SUCCESS)
787 {
788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
789 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
790 goto handle_failure;
791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]792 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
793 + sizeof(tHalCfg) + tlvStruct->length));
794
795 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
796 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
797 tlvStruct->length = sizeof(tANI_U32);
798 configDataValue = (tANI_U32 *)(tlvStruct + 1);
799 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
800 configDataValue ) != eSIR_SUCCESS)
801 {
802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
803 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
804 goto handle_failure;
805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]806 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
807 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]808 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
809 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
810 tlvStruct->length = sizeof(tANI_U32);
811 configDataValue = (tANI_U32 *)(tlvStruct + 1);
812 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
813 configDataValue ) != eSIR_SUCCESS)
814 {
815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
816 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
817 goto handle_failure;
818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]819 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
820 + sizeof(tHalCfg) + tlvStruct->length));
821
822 /* QWLAN_HAL_CFG_FIXED_RATE */
823 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
824 tlvStruct->length = sizeof(tANI_U32);
825 configDataValue = (tANI_U32 *)(tlvStruct + 1);
826 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
827 != eSIR_SUCCESS)
828 {
829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
830 "Failed to get value for WNI_CFG_FIXED_RATE");
831 goto handle_failure;
832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]833 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
834 + sizeof(tHalCfg) + tlvStruct->length));
835
836 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
837 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
838 tlvStruct->length = sizeof(tANI_U32);
839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
840 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
841 != eSIR_SUCCESS)
842 {
843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
844 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
845 goto handle_failure;
846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]847 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
848 + sizeof(tHalCfg) + tlvStruct->length));
849
850 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
851 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
852 tlvStruct->length = sizeof(tANI_U32);
853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
854 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
855 configDataValue ) != eSIR_SUCCESS)
856 {
857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
858 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
859 goto handle_failure;
860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]861 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
862 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]863 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
864 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
865 tlvStruct->length = sizeof(tANI_U32);
866 configDataValue = (tANI_U32 *)(tlvStruct + 1);
867 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
868 configDataValue ) != eSIR_SUCCESS)
869 {
870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
871 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
872 goto handle_failure;
873 }
874 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
875 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]876 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
877 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
878 tlvStruct->length = sizeof(tANI_U32);
879 configDataValue = (tANI_U32 *)(tlvStruct + 1);
880 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
881 configDataValue ) != eSIR_SUCCESS)
882 {
883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
884 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
885 goto handle_failure;
886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]887 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
888 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]889 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
890 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
891 tlvStruct->length = sizeof(tANI_U32);
892 configDataValue = (tANI_U32 *)(tlvStruct + 1);
893 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
894 configDataValue ) != eSIR_SUCCESS)
895 {
896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
897 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
898 goto handle_failure;
899 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
901 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]902 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
903 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
904 tlvStruct->length = sizeof(tANI_U32);
905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
906 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
907 configDataValue ) != eSIR_SUCCESS)
908 {
909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
910 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
911 goto handle_failure;
912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
914 + sizeof(tHalCfg) + tlvStruct->length);
915
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
917 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
925 goto handle_failure;
926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]927 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
928 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]929 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
930 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
938 goto handle_failure;
939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]940 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
941 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]942 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
943 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
944 tlvStruct->length = sizeof(tANI_U32);
945 configDataValue = (tANI_U32 *)(tlvStruct + 1);
946 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
947 eSIR_SUCCESS)
948 {
949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
950 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
951 goto handle_failure;
952 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]953 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
954 + sizeof(tHalCfg) + tlvStruct->length);
955
956 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
957 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
965 goto handle_failure;
966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]967 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
968 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]969 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
970 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
971 tlvStruct->length = sizeof(tANI_U32);
972 configDataValue = (tANI_U32 *)(tlvStruct + 1);
973 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
974 configDataValue ) != eSIR_SUCCESS)
975 {
976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
977 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
978 goto handle_failure;
979 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]980 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
981 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]982 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
983 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
984 tlvStruct->length = sizeof(tANI_U32);
985 configDataValue = (tANI_U32 *)(tlvStruct + 1);
986 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
987 configDataValue ) != eSIR_SUCCESS)
988 {
989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
990 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
991 goto handle_failure;
992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]993 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
994 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
996 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
997 tlvStruct->length = sizeof(tANI_U32);
998 configDataValue = (tANI_U32 *)(tlvStruct + 1);
999 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1000 configDataValue ) != eSIR_SUCCESS)
1001 {
1002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1003 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1004 goto handle_failure;
1005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1006 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1007 + sizeof(tHalCfg) + tlvStruct->length);
1008
1009 /* QWLAN_HAL_CFG_STATS_PERIOD */
1010 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1011 tlvStruct->length = sizeof(tANI_U32);
1012 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1013 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1014 eSIR_SUCCESS)
1015 {
1016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1017 "Failed to get value for WNI_CFG_STATS_PERIOD");
1018 goto handle_failure;
1019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1021 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1022 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1023 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1024 tlvStruct->length = sizeof(tANI_U32);
1025 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1026 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1027 eSIR_SUCCESS)
1028 {
1029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1030 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1031 goto handle_failure;
1032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1034 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1036 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1037 tlvStruct->length = sizeof(tANI_U32);
1038 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1039 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1040 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1043 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1044 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1045 tlvStruct->length = sizeof(tANI_U32);
1046 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1047 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1048 != eSIR_SUCCESS)
1049 {
1050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1051 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1052 goto handle_failure;
1053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1054 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1055 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1056 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1057 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1058 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1059 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1060 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1061 &strLength) != eSIR_SUCCESS)
1062 {
1063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1064 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1065 goto handle_failure;
1066 }
1067 tlvStruct->length = strLength;
1068 /* calculate the pad bytes to have the CFG in aligned format */
1069 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1070 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1071 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1072 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1073 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1074 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1075 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1076 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1077 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1078 &strLength) != eSIR_SUCCESS)
1079 {
1080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1081 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1082 goto handle_failure;
1083 }
1084 tlvStruct->length = strLength;
1085 /* calculate the pad bytes to have the CFG in aligned format */
1086 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1087 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1091 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1092 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1095 &strLength) != eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1099 goto handle_failure;
1100 }
1101 tlvStruct->length = strLength;
1102 /* calculate the pad bytes to have the CFG in aligned format */
1103 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1104 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1105 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1106 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1107 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1108 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1109 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1110 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1111 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1112 &strLength) != eSIR_SUCCESS)
1113 {
1114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1115 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1116 goto handle_failure;
1117 }
1118 tlvStruct->length = strLength;
1119 /* calculate the pad bytes to have the CFG in aligned format */
1120 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1121 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1122 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1123 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1124 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1125 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1126 tlvStruct->length = sizeof(tANI_U32);
1127 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1128 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1129 != eSIR_SUCCESS)
1130 {
1131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1132 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1133 goto handle_failure;
1134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1135 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1136 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1137 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1138 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1139 tlvStruct->length = sizeof(tANI_U32);
1140 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1141 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1142 != eSIR_SUCCESS)
1143 {
1144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1145 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1146 goto handle_failure;
1147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1148 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1149 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1150 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1151 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1152 tlvStruct->length = sizeof(tANI_U32);
1153 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1154 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1155 != eSIR_SUCCESS)
1156 {
1157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1158 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1159 goto handle_failure;
1160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1162 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1163 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1164 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1165 tlvStruct->length = sizeof(tANI_U32);
1166 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1167 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1168 != eSIR_SUCCESS)
1169 {
1170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1171 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1172 goto handle_failure;
1173 }
1174 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1175 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1177 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1178 tlvStruct->length = sizeof(tANI_U32);
1179 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1180 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1181 != eSIR_SUCCESS)
1182 {
1183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1184 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1185 goto handle_failure;
1186 }
1187 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1188 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1190 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1191 tlvStruct->length = sizeof(tANI_U32);
1192 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1193 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1194 != eSIR_SUCCESS)
1195 {
1196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1197 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1198 goto handle_failure;
1199 }
1200 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1201 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1203 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1204 tlvStruct->length = sizeof(tANI_U32);
1205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1206 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1207 != eSIR_SUCCESS)
1208 {
1209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1210 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1211 goto handle_failure;
1212 }
1213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1214 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1215 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1216 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1217 tlvStruct->length = sizeof(tANI_U32);
1218 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1219 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1220 != eSIR_SUCCESS)
1221 {
1222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1223 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1224 goto handle_failure;
1225 }
1226 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1227 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1228 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1229 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1230 tlvStruct->length = sizeof(tANI_U32);
1231 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1232 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1233 != eSIR_SUCCESS)
1234 {
1235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1236 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1237 goto handle_failure;
1238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1239 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1240 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1241 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1242 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1243 tlvStruct->length = sizeof(tANI_U32);
1244 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1245 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1246 != eSIR_SUCCESS)
1247 {
1248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1249 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1250 goto handle_failure;
1251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1252 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1253 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1254 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1255 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1256 tlvStruct->length = sizeof(tANI_U32);
1257 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1258 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1259 != eSIR_SUCCESS)
1260 {
1261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1262 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1263 goto handle_failure;
1264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1265 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1266 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1267 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1268 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1269 * into FW, so the parameters are added here.
1270 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1271 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1272 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1273 tlvStruct->length = sizeof(tANI_U32);
1274 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1275 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1276 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1277 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1278 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1279 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1280 tlvStruct->length = sizeof(tANI_U32);
1281 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1282 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1286 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1290 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1291 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1292 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1293 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1294 tlvStruct->length = sizeof(tANI_U32);
1295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1296 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1297 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1298 + sizeof(tHalCfg) + tlvStruct->length) ;
1299
1300 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1301 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1302 tlvStruct->length = sizeof(tANI_U32);
1303 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1304 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1305 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1306 + sizeof(tHalCfg) + tlvStruct->length) ;
1307
1308 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1309 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1310 tlvStruct->length = sizeof(tANI_U32);
1311 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1312 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1313 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1314 + sizeof(tHalCfg) + tlvStruct->length) ;
1315
1316 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1317 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1321 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1322 + sizeof(tHalCfg) + tlvStruct->length) ;
1323
1324 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1325 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1329 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1330 + sizeof(tHalCfg) + tlvStruct->length) ;
1331
1332 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1333 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1334 tlvStruct->length = sizeof(tANI_U32);
1335 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1336 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1337 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1338 + sizeof(tHalCfg) + tlvStruct->length) ;
1339
1340 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1341 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1342 tlvStruct->length = sizeof(tANI_U32);
1343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1344 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1345 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1346 + sizeof(tHalCfg) + tlvStruct->length) ;
1347
1348 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1349 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1350 tlvStruct->length = sizeof(tANI_U32);
1351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1352 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
1355
1356 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1357 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1358 tlvStruct->length = sizeof(tANI_U32);
1359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1360 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
1363
1364 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1365 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1366 tlvStruct->length = sizeof(tANI_U32);
1367 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1368 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1369 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1370 + sizeof(tHalCfg) + tlvStruct->length) ;
1371
1372 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1373 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1374 tlvStruct->length = sizeof(tANI_U32);
1375 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1376 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1377 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1378 + sizeof(tHalCfg) + tlvStruct->length) ;
1379
1380 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1396 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1397 {
1398 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1399 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1400 tlvStruct->length = sizeof(tANI_U32);
1401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1402 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1403 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1404 + sizeof(tHalCfg) + tlvStruct->length) ;
1405
1406 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1407 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1408 tlvStruct->length = sizeof(tANI_U32);
1409 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1410 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1411 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1412 + sizeof(tHalCfg) + tlvStruct->length) ;
1413
1414 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1415 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1416 tlvStruct->length = sizeof(tANI_U32);
1417 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1418 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1419 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1420 + sizeof(tHalCfg) + tlvStruct->length) ;
1421
1422 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1423 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1424 tlvStruct->length = sizeof(tANI_U32);
1425 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1426 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1427 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1428 + sizeof(tHalCfg) + tlvStruct->length) ;
1429 }
1430
1431 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1432 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1433 tlvStruct->length = sizeof(tANI_U32);
1434 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1435 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1436 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1437 + sizeof(tHalCfg) + tlvStruct->length) ;
1438
1439 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1440 {
1441 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1442 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1443 tlvStruct->length = sizeof(tANI_U32);
1444 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1445 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1446 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1447 + sizeof(tHalCfg) + tlvStruct->length) ;
1448 }
1449
1450 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1451 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1452 tlvStruct->length = sizeof(tANI_U32);
1453 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1454 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1455 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1456 + sizeof(tHalCfg) + tlvStruct->length) ;
1457
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1458 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1459 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1460 tlvStruct->length = sizeof(tANI_U32);
1461 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1462 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1463 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1464 wcnssCompiledApiVersion.minor,
1465 wcnssCompiledApiVersion.version,
1466 wcnssCompiledApiVersion.revision);
1467 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1468 + sizeof(tHalCfg) + tlvStruct->length) ;
1469
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1470 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1471 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1472 tlvStruct->length = sizeof(tANI_U32);
1473 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1474 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1475 configDataValue ) != eSIR_SUCCESS)
1476 {
1477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1478 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1479 goto handle_failure;
1480 }
1481
1482 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1483 + sizeof(tHalCfg) + tlvStruct->length) ;
1484 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1485 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1486 tlvStruct->length = sizeof(tANI_U32);
1487 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1488 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1489 configDataValue ) != eSIR_SUCCESS)
1490 {
1491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1492 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1493 goto handle_failure;
1494 }
1495
1496 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1497 + sizeof(tHalCfg) + tlvStruct->length) ;
1498
1499 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1500 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1501 tlvStruct->length = sizeof(tANI_U32);
1502 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1503 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1504 != eSIR_SUCCESS)
1505 {
1506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1507 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1508 goto handle_failure;
1509 }
1510
1511 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1512 + sizeof(tHalCfg) + tlvStruct->length) ;
1513
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1514 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1515 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1516 tlvStruct->length = sizeof(tANI_U32);
1517 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1518 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1519 != eSIR_SUCCESS)
1520 {
1521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1522 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1523 goto handle_failure;
1524 }
1525
1526 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1527 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1528#ifdef WLAN_SOFTAP_VSTA_FEATURE
1529 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1533 != eSIR_SUCCESS)
1534 {
1535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1536 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1537 goto handle_failure;
1538 }
1539
1540 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1541 + sizeof(tHalCfg) + tlvStruct->length) ;
1542#endif
1543
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1544 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1545 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1546 tlvStruct->length = sizeof(tANI_U32);
1547 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1548
1549 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1550 != eSIR_SUCCESS)
1551 {
1552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1553 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1554 goto handle_failure;
1555 }
1556
1557 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1558 + sizeof(tHalCfg) + tlvStruct->length) ;
1559
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1560/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1561 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1562 tlvStruct->length = sizeof(tANI_U32);
1563 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1564 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1565 configDataValue ) != eSIR_SUCCESS)
1566 {
1567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1568 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1569 goto handle_failure;
1570 }
1571
1572 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1573 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1574#ifdef FEATURE_WLAN_TDLS
1575 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1576 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1577 tlvStruct->length = sizeof(tANI_U32);
1578 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1579 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1580 configDataValue ) != eSIR_SUCCESS)
1581 {
1582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1583 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1584 goto handle_failure;
1585 }
1586 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1587 + sizeof(tHalCfg) + tlvStruct->length) ;
1588
1589 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1590 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1594 configDataValue ) != eSIR_SUCCESS)
1595 {
1596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1597 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1598 goto handle_failure;
1599 }
1600 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1601 + sizeof(tHalCfg) + tlvStruct->length) ;
1602 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1603 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1607 configDataValue ) != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1611 goto handle_failure;
1612 }
1613 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1614 + sizeof(tHalCfg) + tlvStruct->length) ;
1615 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1616 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1617 tlvStruct->length = sizeof(tANI_U32);
1618 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1619 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1620 configDataValue ) != eSIR_SUCCESS)
1621 {
1622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1623 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1624 goto handle_failure;
1625 }
1626 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1627 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1628 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1629 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1630 tlvStruct->length = sizeof(tANI_U32);
1631 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1632 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1633 configDataValue ) != eSIR_SUCCESS)
1634 {
1635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1636 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1637 goto handle_failure;
1638 }
1639 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1640 + sizeof(tHalCfg) + tlvStruct->length) ;
1641
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1642#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1643
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1644 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1645 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1646 tlvStruct->length = sizeof(tANI_U32);
1647 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1648 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1649 configDataValue ) != eSIR_SUCCESS)
1650 {
1651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1652 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1653 goto handle_failure;
1654 }
1655
1656 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1657 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1658
1659 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1660 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1661 tlvStruct->length = sizeof(tANI_U32);
1662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1663 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1664 != eSIR_SUCCESS)
1665 {
1666 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1667 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1668 goto handle_failure;
1669 }
1670 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1671 + sizeof(tHalCfg) + tlvStruct->length));
1672
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1673 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1674 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1675 tlvStruct->length = sizeof(tANI_U32);
1676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1677 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1678 configDataValue ) != eSIR_SUCCESS)
1679 {
1680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1681 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1682 goto handle_failure;
1683 }
1684
1685 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1686 + sizeof(tHalCfg) + tlvStruct->length) ;
1687
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1688 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1689 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1690 tlvStruct->length = sizeof(tANI_U32);
1691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1692 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1693 configDataValue ) != eSIR_SUCCESS)
1694 {
1695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1696 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1697 goto handle_failure;
1698 }
1699 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1700 + sizeof(tHalCfg) + tlvStruct->length) ;
1701
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1702 /* QWLAN_HAL_CFG_ATH_DISABLE */
1703 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1704 tlvStruct->length = sizeof(tANI_U32);
1705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1706 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1707 configDataValue ) != eSIR_SUCCESS)
1708 {
1709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1710 "Failed to get value for WNI_CFG_ATH_DISABLE");
1711 goto handle_failure;
1712 }
1713 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1714 + sizeof(tHalCfg) + tlvStruct->length) ;
1715
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1717 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
1730 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1731 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1732 tlvStruct->length = sizeof(tANI_U32);
1733 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1734 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1735 configDataValue ) != eSIR_SUCCESS)
1736 {
1737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1738 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1739 goto handle_failure;
1740 }
1741 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1742 + sizeof(tHalCfg) + tlvStruct->length) ;
1743
1744 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1745 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1746 tlvStruct->length = sizeof(tANI_U32);
1747 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1748 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1749 configDataValue ) != eSIR_SUCCESS)
1750 {
1751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1752 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1753 goto handle_failure;
1754 }
1755 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1756 + sizeof(tHalCfg) + tlvStruct->length) ;
1757
1758 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1759 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1760 tlvStruct->length = sizeof(tANI_U32);
1761 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1762 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1763 configDataValue ) != eSIR_SUCCESS)
1764 {
1765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1766 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1767 goto handle_failure;
1768 }
1769 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1770 + sizeof(tHalCfg) + tlvStruct->length) ;
1771
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1772 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1773 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1774 tlvStruct->length = sizeof(tANI_U32);
1775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1776 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1777 configDataValue ) != eSIR_SUCCESS)
1778 {
1779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1780 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1781 goto handle_failure;
1782 }
1783 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1784 + sizeof(tHalCfg) + tlvStruct->length) ;
1785
1786 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1787 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1788 tlvStruct->length = sizeof(tANI_U32);
1789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1790 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1791 configDataValue ) != eSIR_SUCCESS)
1792 {
1793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1794 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1795 goto handle_failure;
1796 }
1797 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1798 + sizeof(tHalCfg) + tlvStruct->length) ;
1799
1800 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1801 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1802 tlvStruct->length = sizeof(tANI_U32);
1803 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1804 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1805 configDataValue ) != eSIR_SUCCESS)
1806 {
1807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1808 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1809 goto handle_failure;
1810 }
1811 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1812 + sizeof(tHalCfg) + tlvStruct->length) ;
1813
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1814 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1815 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1816 tlvStruct->length = sizeof(tANI_U32);
1817 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1818 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1819 configDataValue ) != eSIR_SUCCESS)
1820 {
1821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1822 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1823 goto handle_failure;
1824 }
1825 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1826 + sizeof(tHalCfg) + tlvStruct->length) ;
1827
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1828 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1829 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1830 tlvStruct->length = sizeof(tANI_U32);
1831 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1832
1833 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1834 configDataValue ) != eSIR_SUCCESS)
1835 {
1836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1837 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1838 goto handle_failure;
1839 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1840 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1841 + sizeof(tHalCfg) + tlvStruct->length) ;
1842
1843 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1844 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1845 tlvStruct->length = sizeof(tANI_U32);
1846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1847
1848 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1849 configDataValue ) != eSIR_SUCCESS)
1850 {
1851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1852 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1853 goto handle_failure;
1854 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1855 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1856 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1857
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1858 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1859 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1860 tlvStruct->length = sizeof(tANI_U32);
1861 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1862
1863 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1864 configDataValue ) != eSIR_SUCCESS)
1865 {
1866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1867 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1868 goto handle_failure;
1869 }
1870 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1871 + sizeof(tHalCfg) + tlvStruct->length) ;
1872
1873 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1874 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1875 tlvStruct->length = sizeof(tANI_U32);
1876 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1877
1878 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892
1893 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1894 configDataValue ) != eSIR_SUCCESS)
1895 {
1896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1897 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1898 goto handle_failure;
1899 }
1900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1901 + sizeof(tHalCfg) + tlvStruct->length) ;
1902
1903 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1904 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1905 tlvStruct->length = sizeof(tANI_U32);
1906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1907
1908 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1909 configDataValue ) != eSIR_SUCCESS)
1910 {
1911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1912 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1913 goto handle_failure;
1914 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1915 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1916 + sizeof(tHalCfg) + tlvStruct->length) ;
1917
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]1918 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
1919 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
1920 tlvStruct->length = sizeof(tANI_U32);
1921 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1922
1923 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
1924 configDataValue ) != eSIR_SUCCESS)
1925 {
1926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1927 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
1928 goto handle_failure;
1929 }
1930 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1931 + sizeof(tHalCfg) + tlvStruct->length) ;
1932
1933 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
1934 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
1935 tlvStruct->length = sizeof(tANI_U32);
1936 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1937
1938 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
1939 configDataValue ) != eSIR_SUCCESS)
1940 {
1941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1942 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
1943 goto handle_failure;
1944 }
1945 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1946 + sizeof(tHalCfg) + tlvStruct->length) ;
1947
1948 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
1949 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
1950 tlvStruct->length = sizeof(tANI_U32);
1951 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1952
1953 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
1954 configDataValue ) != eSIR_SUCCESS)
1955 {
1956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1957 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
1958 goto handle_failure;
1959 }
1960 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1961 + sizeof(tHalCfg) + tlvStruct->length) ;
1962
1963 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
1964 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
1965 tlvStruct->length = sizeof(tANI_U32);
1966 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1967
1968 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
1969 configDataValue ) != eSIR_SUCCESS)
1970 {
1971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1972 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
1973 goto handle_failure;
1974 }
1975 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1976 + sizeof(tHalCfg) + tlvStruct->length) ;
1977
1978 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
1979 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
1980 tlvStruct->length = sizeof(tANI_U32);
1981 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1982
1983 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
1984 configDataValue ) != eSIR_SUCCESS)
1985 {
1986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1987 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
1988 goto handle_failure;
1989 }
1990 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1991 + sizeof(tHalCfg) + tlvStruct->length) ;
1992
1993 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
1994 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
1995 tlvStruct->length = sizeof(tANI_U32);
1996 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1997
1998 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
1999 configDataValue ) != eSIR_SUCCESS)
2000 {
2001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2002 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2003 goto handle_failure;
2004 }
2005 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2006 + sizeof(tHalCfg) + tlvStruct->length) ;
2007
2008 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2009 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2010 tlvStruct->length = sizeof(tANI_U32);
2011 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2012
2013 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2014 configDataValue ) != eSIR_SUCCESS)
2015 {
2016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2017 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2018 goto handle_failure;
2019 }
2020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2021 + sizeof(tHalCfg) + tlvStruct->length) ;
2022
2023 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2024 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2025 tlvStruct->length = sizeof(tANI_U32);
2026 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2027
2028 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2029 configDataValue ) != eSIR_SUCCESS)
2030 {
2031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2032 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2033 goto handle_failure;
2034 }
2035 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2036 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu03d961b2014-09-19 16:45:00 +0530[diff] [blame]2037
2038 /* QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE */
2039 tlvStruct->type = QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE ;
2040 tlvStruct->length = sizeof(tANI_U32);
2041 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2042
2043 if (wlan_cfgGetInt(pMac, WNI_CFG_BURST_MODE_BE_TXOP_VALUE,
2044 configDataValue ) != eSIR_SUCCESS)
2045 {
2046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2047 "Failed to get value for WNI_CFG_BURST_MODE_BE_TXOP_VALUE");
2048 goto handle_failure;
2049 }
2050 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2051 + sizeof(tHalCfg) + tlvStruct->length) ;
2052
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2053 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2054#ifdef WLAN_DEBUG
2055 {
2056 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2057 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2058 "****** Dumping CFG TLV ***** ");
2059 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2060 {
2061 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2062 "%02x %02x %02x %02x %02x %02x %02x %02x",
2063 tlvStructStart[i],
2064 tlvStructStart[i+1],
2065 tlvStructStart[i+2],
2066 tlvStructStart[i+3],
2067 tlvStructStart[i+4],
2068 tlvStructStart[i+5],
2069 tlvStructStart[i+6],
2070 tlvStructStart[i+7]);
2071 }
2072 /* Dump the bytes in the last line*/
2073 for (; i < wdiStartParams->usConfigBufferLen; i++)
2074 {
2075 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2076 "%02x ",tlvStructStart[i]);
2077 }
2078 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2079 "**************************** ");
2080 }
2081#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2082 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2083handle_failure:
2084 vos_mem_free(configParam);
2085 return VOS_STATUS_E_FAILURE;
2086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2087/*
2088 * FUNCTION: WDA_wdiCompleteCB
2089 * call the voss call back function
2090 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2091void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2092{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2093 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2094 tWDA_CbContext *wdaContext;
2095
2096 if(NULL == pWdaParams)
2097 {
2098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2099 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2100 VOS_ASSERT(0) ;
2101 return ;
2102 }
2103
2104 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2105
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2106 if (NULL == wdaContext)
2107 {
2108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2109 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2110 return ;
2111 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2112
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2113 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2114 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2115 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2116 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2117 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2118 vos_mem_free(pWdaParams);
2119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2120 if(WDI_STATUS_SUCCESS != status)
2121 {
2122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2123 "WDI stop callback returned failure" );
2124 VOS_ASSERT(0) ;
2125 }
2126 else
2127 {
2128 wdaContext->wdaState = WDA_STOP_STATE;
2129 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2130
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2131 /* FTM Driver stop procedure should be synced.
2132 * Stop and Close will happen on same context */
2133 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2134 {
2135 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2136 {
2137 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2138 "%s: FTM Stop Event Set Fail", __func__);
2139 VOS_ASSERT(0);
2140 }
2141 }
2142
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2143 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2144 vos_WDAComplete_cback(wdaContext->pVosContext);
2145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2146 return ;
2147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148/*
2149 * FUNCTION: WDA_stop
2150 * call WDI_stop
2151 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2152VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2153{
2154 WDI_Status wdiStatus;
2155 VOS_STATUS status = VOS_STATUS_SUCCESS;
2156 WDI_StopReqParamsType *wdiStopReq;
2157 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2158 tWDA_ReqParams *pWdaParams ;
2159
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2160 if (NULL == pWDA)
2161 {
2162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2163 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2164 VOS_ASSERT(0);
2165 return VOS_STATUS_E_FAILURE;
2166 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2167 if (pWDA->wdiFailed == true)
2168 {
2169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2170 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2171 return VOS_STATUS_E_ALREADY;
2172 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2174 /* FTM mode stay START_STATE */
2175 if( (WDA_READY_STATE != pWDA->wdaState) &&
2176 (WDA_INIT_STATE != pWDA->wdaState) &&
2177 (WDA_START_STATE != pWDA->wdaState) )
2178 {
2179 VOS_ASSERT(0);
2180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2181 wdiStopReq = (WDI_StopReqParamsType *)
2182 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2183 if(NULL == wdiStopReq)
2184 {
2185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2186 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 VOS_ASSERT(0);
2188 return VOS_STATUS_E_NOMEM;
2189 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2191 wdiStopReq->wdiStopReason = reason;
2192 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2193
2194 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2195 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2196 {
2197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2198 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 VOS_ASSERT(0);
2200 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2201 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2202 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2203
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2204 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2205 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2206 {
2207 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2208 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2209 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2210
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2211 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2212 pWdaParams->wdaMsgParam = NULL;
2213 pWdaParams->pWdaContext = pWDA;
2214
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2215 /* call WDI stop */
2216 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2217 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2218
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2219 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2220 {
2221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2222 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2223 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2224 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2225 status = VOS_STATUS_E_FAILURE;
2226 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2227
2228 /* FTM Driver stop procedure should be synced.
2229 * Stop and Close will happen on same context */
2230 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2231 {
2232 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2233 WDI_RESPONSE_TIMEOUT);
2234 if (status != VOS_STATUS_SUCCESS)
2235 {
2236 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2237 "%s: FTM Stop Timepoout", __func__);
2238 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2239 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2240 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2241 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2242 return status;
2243}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2244/*
2245 * FUNCTION: WDA_close
2246 * call WDI_close and free the WDA context
2247 */
2248VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2249{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2250 VOS_STATUS status = VOS_STATUS_SUCCESS;
2251 WDI_Status wstatus;
2252 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2253 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2254 if (NULL == wdaContext)
2255 {
2256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2257 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2258 return VOS_STATUS_E_FAILURE;
2259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2260 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2261 (WDA_STOP_STATE != wdaContext->wdaState))
2262 {
2263 VOS_ASSERT(0);
2264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2265 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2266 wstatus = WDI_Close();
2267 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2268 {
2269 status = VOS_STATUS_E_FAILURE;
2270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2271 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2272 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2273 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2274 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2275 {
2276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2277 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2278 status = VOS_STATUS_E_FAILURE;
2279 }
2280
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2281 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2282 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2283 {
2284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2285 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 status = VOS_STATUS_E_FAILURE;
2287 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2288 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2289 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2290 {
2291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2292 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2293 status = VOS_STATUS_E_FAILURE;
2294 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2295 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2296 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2297 {
2298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2299 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2300 status = VOS_STATUS_E_FAILURE;
2301 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2302 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2303 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2304 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2305 {
2306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2307 "error in WDA close " );
2308 status = VOS_STATUS_E_FAILURE;
2309 }
2310 return status;
2311}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2312/*
2313 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2314 * returns 1 if the compiled version is greater than or equal to the input version
2315 */
2316
2317uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2318{
2319 VOS_STATUS status = VOS_STATUS_SUCCESS;
2320 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2321 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2322 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2323 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2324 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2325 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2326 (compiledVersion.revision >= revision)))
2327 return 1;
2328 else
2329 return 0;
2330}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2331/*
2332 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2333 * returns 1 if the compiled version is greater than or equal to the input version
2334 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2336{
2337 VOS_STATUS status = VOS_STATUS_SUCCESS;
2338 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2339 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2340 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2341 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2342 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2343 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2344 (reportedVersion.revision >= revision)))
2345 return 1;
2346 else
2347 return 0;
2348}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349/*
2350 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2351 * Returns the version of the WCNSS WLAN API with which the HOST
2352 * device driver was compiled
2353 */
2354VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2355 tSirVersionType *pVersion)
2356{
2357 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2358 if ((NULL == pvosGCtx) || (NULL == pVersion))
2359 {
2360 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2361 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2362 VOS_ASSERT(0);
2363 return VOS_STATUS_E_FAILURE;
2364 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2365 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2366 if (NULL == pWDA )
2367 {
2368 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2369 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2370 VOS_ASSERT(0);
2371 return VOS_STATUS_E_FAILURE;
2372 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2373 *pVersion = pWDA->wcnssWlanCompiledVersion;
2374 return VOS_STATUS_SUCCESS;
2375}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2376/*
2377 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2378 * Returns the version of the WCNSS WLAN API with which the WCNSS
2379 * device driver was compiled
2380 */
2381VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2382 tSirVersionType *pVersion)
2383{
2384 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2385 if ((NULL == pvosGCtx) || (NULL == pVersion))
2386 {
2387 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2388 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2389 VOS_ASSERT(0);
2390 return VOS_STATUS_E_FAILURE;
2391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2392 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2393 if (NULL == pWDA )
2394 {
2395 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2396 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2397 VOS_ASSERT(0);
2398 return VOS_STATUS_E_FAILURE;
2399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2400 *pVersion = pWDA->wcnssWlanReportedVersion;
2401 return VOS_STATUS_SUCCESS;
2402}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2403/*
2404 * FUNCTION: WDA_GetWcnssSoftwareVersion
2405 * Returns the WCNSS Software version string
2406 */
2407VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2408 tANI_U8 *pVersion,
2409 tANI_U32 versionBufferSize)
2410{
2411 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2412 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2413 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2414 if ((NULL == pvosGCtx) || (NULL == pVersion))
2415 {
2416 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2417 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 VOS_ASSERT(0);
2419 return VOS_STATUS_E_FAILURE;
2420 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2422 if (NULL == pWDA )
2423 {
2424 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2425 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2426 VOS_ASSERT(0);
2427 return VOS_STATUS_E_FAILURE;
2428 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2429 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2430 return VOS_STATUS_SUCCESS;
2431}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2432/*
2433 * FUNCTION: WDA_GetWcnssHardwareVersion
2434 * Returns the WCNSS Hardware version string
2435 */
2436VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2437 tANI_U8 *pVersion,
2438 tANI_U32 versionBufferSize)
2439{
2440 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2441 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2442 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2443 if ((NULL == pvosGCtx) || (NULL == pVersion))
2444 {
2445 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2446 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2447 VOS_ASSERT(0);
2448 return VOS_STATUS_E_FAILURE;
2449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2450 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2451 if (NULL == pWDA )
2452 {
2453 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2454 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2455 VOS_ASSERT(0);
2456 return VOS_STATUS_E_FAILURE;
2457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2459 return VOS_STATUS_SUCCESS;
2460}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2461/*
2462 * FUNCTION: WDA_WniCfgDnld
2463 * Trigger CFG Download
2464 */
2465VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2466{
2467 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2468 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2469
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2470 if (NULL == pMac )
2471 {
2472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2473 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2474 VOS_ASSERT(0);
2475 return VOS_STATUS_E_FAILURE;
2476 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2477 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2478 return vosStatus;
2479}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2480/* -----------------------------------------------------------------
2481 * WDI interface
2482 * -----------------------------------------------------------------
2483 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2484/*
2485 * FUNCTION: WDA_suspendDataTxCallback
2486 * call back function called from TL after suspend Transmission
2487 */
2488VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2489 v_U8_t* ucSTAId,
2490 VOS_STATUS vosStatus)
2491{
2492 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2494 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2495 if (NULL == pWDA )
2496 {
2497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2498 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2499 VOS_ASSERT(0);
2500 return VOS_STATUS_E_FAILURE;
2501 }
2502 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2503 {
2504 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2505 }
2506 else
2507 {
2508 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2509 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2510 /* Trigger the event to bring the WDA TL suspend function to come
2511 * out of wait*/
2512 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2513 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2514 {
2515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2516 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2518 /* If TL suspended had timedout before this callback was called, resume back
2519 * TL.*/
2520 if (pWDA->txSuspendTimedOut)
2521 {
2522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2523 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 WDA_ResumeDataTx(pWDA);
2525 pWDA->txSuspendTimedOut = FALSE;
2526 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2527 return VOS_STATUS_SUCCESS;
2528}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2529/*
2530 * FUNCTION: WDA_suspendDataTx
2531 * Update TL to suspend the data Transmission
2532 */
2533VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2534{
2535 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2536 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2537
2538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2539 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2540 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 if (pWDA->txSuspendTimedOut)
2542 {
2543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2544 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2545 return status;
2546 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2547 /* Reset the event to be not signalled */
2548 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2549 if(!VOS_IS_STATUS_SUCCESS(status))
2550 {
2551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2552 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2553 return VOS_STATUS_E_FAILURE;
2554 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2555 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2556 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2557 WDA_SuspendDataTxCallback);
2558 if(status != VOS_STATUS_SUCCESS)
2559 {
2560 return status;
2561 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2562 /* Wait for the event to be set by the TL, to get the response of
2563 * suspending the TX queues, this event should be set by the Callback
2564 * function called by TL*/
2565 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2566 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2567 if(!VOS_IS_STATUS_SUCCESS(status))
2568 {
2569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2570 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2571 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2572 /* Set this flag to true when TL suspend times out, so that when TL
2573 * suspend eventually happens and calls the callback, TL can be resumed
2574 * right away by looking at this flag when true.*/
2575 pWDA->txSuspendTimedOut = TRUE;
2576 }
2577 else
2578 {
2579 pWDA->txSuspendTimedOut = FALSE;
2580 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2581 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2582 {
2583 status = VOS_STATUS_SUCCESS;
2584 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2585 return status;
2586}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587/*
2588 * FUNCTION: WDA_resumeDataTx
2589 * Update TL to resume the data Transmission
2590 */
2591VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2592{
2593 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2594
2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2596 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2597
2598 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599 return status;
2600}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601/*
2602 * FUNCTION: WDA_InitScanReqCallback
2603 * Trigger Init SCAN callback
2604 */
2605void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2606{
2607 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2608 tWDA_CbContext *pWDA;
2609 tInitScanParams *pWDA_ScanParam ;
2610 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2612 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 if(NULL == pWdaParams)
2614 {
2615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2616 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2617 VOS_ASSERT(0) ;
2618 return ;
2619 }
2620 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2621 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 if(NULL == pWDA_ScanParam)
2623 {
2624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2625 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2626 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2627 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2628 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2629 return ;
2630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2631 if(WDI_STATUS_SUCCESS != wdiStatus)
2632 {
2633 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2634 if(VOS_STATUS_SUCCESS != status)
2635 {
2636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2637 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2638 }
2639 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2640 /* free WDI command buffer */
2641 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2642 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2643
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2644
2645 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2646 /* without converting the Status to Failure or Success Just
2647 pass the same status to lim */
2648 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2649 /* send SCAN RSP message back to PE */
2650 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651 return ;
2652}
2653
2654/*
2655 * FUNCTION: WDA_ProcessInitScanReq
2656 * Trigger Init SCAN in DAL
2657 */
2658VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2659 tInitScanParams *initScanParams)
2660{
2661 WDI_Status status = WDI_STATUS_SUCCESS ;
2662 WDI_InitScanReqParamsType *wdiInitScanParam =
2663 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2664 sizeof(WDI_InitScanReqParamsType)) ;
2665 tWDA_ReqParams *pWdaParams;
2666 tANI_U8 i = 0;
2667
2668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2669 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2670 if(NULL == wdiInitScanParam)
2671 {
2672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2673 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2674 VOS_ASSERT(0);
2675 return VOS_STATUS_E_NOMEM;
2676 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2677 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2678 if(NULL == pWdaParams)
2679 {
2680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2681 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2682 VOS_ASSERT(0);
2683 vos_mem_free(wdiInitScanParam);
2684 return VOS_STATUS_E_NOMEM;
2685 }
2686
2687 /* Copy init Scan params to WDI structure */
2688 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2689 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2690 sizeof(tSirMacAddr)) ;
2691 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2692 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2693 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2694 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2695 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2697 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2698 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2699 {
2700 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2701 initScanParams->scanEntry.bssIdx[i] ;
2702 }
2703
2704 /* if Frame length, copy macMgmtHdr or WDI structure */
2705 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2706 {
2707 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2708 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2709 }
2710 wdiInitScanParam->wdiReqStatusCB = NULL ;
2711
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2712 /* Store Init Req pointer, as this will be used for response */
2713 pWdaParams->pWdaContext = pWDA;
2714 pWdaParams->wdaMsgParam = initScanParams;
2715 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2716 /* first try to suspend TX */
2717 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2718 if(WDI_STATUS_SUCCESS != status)
2719 {
2720 goto handleWdiFailure;
2721 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2722 /* call DAL API to pass init scan request to DAL */
2723 status = WDI_InitScanReq(wdiInitScanParam,
2724 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 if(IS_WDI_STATUS_FAILURE(status))
2726 {
2727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2728 "error in WDA Init Scan, Resume Tx " );
2729 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2730 VOS_ASSERT(0) ;
2731
2732 goto handleWdiFailure;
2733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2734 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2735handleWdiFailure:
2736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2737 "Failure in WDI Api, free all the memory " );
2738 /* free WDI command buffer */
2739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2740 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2741 /* send Failure to PE */
2742 initScanParams->status = eSIR_FAILURE ;
2743 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2744 return CONVERT_WDI2VOS_STATUS(status) ;
2745}
2746
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747/*
2748 * FUNCTION: WDA_StartScanReqCallback
2749 * send Start SCAN RSP back to PE
2750 */
2751void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2752 void* pUserData)
2753{
2754 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2755 tWDA_CbContext *pWDA;
2756 tStartScanParams *pWDA_ScanParam;
2757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2758 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2759 if(NULL == pWdaParams)
2760 {
2761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2762 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2763 VOS_ASSERT(0) ;
2764 return ;
2765 }
2766 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2767 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 if(NULL == pWDA_ScanParam)
2769 {
2770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2771 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2772 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2773 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2774 return ;
2775 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2776 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2777 {
2778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2779 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2780 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2781 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2782 return ;
2783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2784 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2785 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2786
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2787
2788 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2789 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2790 /* send SCAN RSP message back to PE */
2791 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2792 return ;
2793}
2794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2795/*
2796 * FUNCTION: WDA_ProcessStartScanReq
2797 * Trigger start SCAN in WDI
2798 */
2799VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2800 tStartScanParams *startScanParams)
2801{
2802 WDI_Status status = WDI_STATUS_SUCCESS;
2803 WDI_StartScanReqParamsType *wdiStartScanParams =
2804 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2805 sizeof(WDI_StartScanReqParamsType)) ;
2806 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2808 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809 if(NULL == wdiStartScanParams)
2810 {
2811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2812 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2813 VOS_ASSERT(0);
2814 return VOS_STATUS_E_NOMEM;
2815 }
2816 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2817 if(NULL == pWdaParams)
2818 {
2819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2820 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 VOS_ASSERT(0);
2822 vos_mem_free(wdiStartScanParams);
2823 return VOS_STATUS_E_NOMEM;
2824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2825 /* Copy init Scan params to WDI structure */
2826 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2827 wdiStartScanParams->wdiReqStatusCB = NULL ;
2828
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2829 /* Store Init Req pointer, as this will be used for response */
2830 /* store Params pass it to WDI */
2831 pWdaParams->pWdaContext = pWDA;
2832 pWdaParams->wdaMsgParam = startScanParams;
2833 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834 /* call DAL API to pass init scan request to DAL */
2835 status = WDI_StartScanReq(wdiStartScanParams,
2836 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2837 /* failure returned by WDI API */
2838 if(IS_WDI_STATUS_FAILURE(status))
2839 {
2840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2841 "Failure in Start Scan WDI API, free all the memory "
2842 "It should be due to previous abort scan." );
2843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2844 vos_mem_free(pWdaParams) ;
2845 startScanParams->status = eSIR_FAILURE ;
2846 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2848 return CONVERT_WDI2VOS_STATUS(status) ;
2849}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2850/*
2851 * FUNCTION: WDA_EndScanReqCallback
2852 * END SCAN callback
2853 */
2854void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2855{
2856 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2857 tWDA_CbContext *pWDA;
2858 tEndScanParams *endScanParam;
2859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2860 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2861 if(NULL == pWdaParams)
2862 {
2863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2864 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2865 VOS_ASSERT(0) ;
2866 return ;
2867 }
2868 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2869 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2870 if(NULL == endScanParam)
2871 {
2872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2873 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2875 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2876 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2877 return ;
2878 }
2879
2880 /* Free WDI command buffer */
2881 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2882 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2884 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2885 /* send response back to PE */
2886 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2887 return ;
2888}
2889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2890/*
2891 * FUNCTION: WDA_ProcessEndScanReq
2892 * Trigger END SCAN in WDI
2893 */
2894VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2895 tEndScanParams *endScanParams)
2896{
2897 WDI_Status status = WDI_STATUS_SUCCESS;
2898 WDI_EndScanReqParamsType *wdiEndScanParams =
2899 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2900 sizeof(WDI_EndScanReqParamsType)) ;
2901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 if(NULL == wdiEndScanParams)
2905 {
2906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2908 VOS_ASSERT(0);
2909 return VOS_STATUS_E_NOMEM;
2910 }
2911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2912 if(NULL == pWdaParams)
2913 {
2914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2916 VOS_ASSERT(0);
2917 vos_mem_free(wdiEndScanParams);
2918 return VOS_STATUS_E_NOMEM;
2919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 /* Copy init Scan params to WDI structure */
2921 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2922 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2923 /* Store Init Req pointer, as this will be used for response */
2924 /* store Params pass it to WDI */
2925 pWdaParams->pWdaContext = pWDA;
2926 pWdaParams->wdaMsgParam = endScanParams;
2927 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2928 /* call DAL API to pass init scan request to DAL */
2929 status = WDI_EndScanReq(wdiEndScanParams,
2930 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2931 if(IS_WDI_STATUS_FAILURE(status))
2932 {
2933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2934 "Failure in End Scan WDI API, free all the memory "
2935 "It should be due to previous abort scan." );
2936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2937 vos_mem_free(pWdaParams) ;
2938 endScanParams->status = eSIR_FAILURE ;
2939 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2941 return CONVERT_WDI2VOS_STATUS(status) ;
2942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943/*
2944 * FUNCTION: WDA_FinishScanReqCallback
2945 * Trigger Finish SCAN callback
2946 */
2947void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2948{
2949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2950 tWDA_CbContext *pWDA;
2951 tFinishScanParams *finishScanParam;
2952 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2954 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2955 if(NULL == pWdaParams)
2956 {
2957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2958 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2959 VOS_ASSERT(0) ;
2960 return ;
2961 }
2962
2963 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2964 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2965 if(NULL == finishScanParam)
2966 {
2967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2968 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2969 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2971 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972 return ;
2973 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2975 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2976 /*
2977 * Now Resume TX, if we reached here means, TX is already suspended, we
2978 * have to resume it unconditionaly
2979 */
2980 status = WDA_ResumeDataTx(pWDA) ;
2981
2982 if(VOS_STATUS_SUCCESS != status)
2983 {
2984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2985 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2986 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2987 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2988 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2989 return ;
2990}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2991/*
2992 * FUNCTION: WDA_ProcessFinshScanReq
2993 * Trigger Finish SCAN in WDI
2994 */
2995VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2996 tFinishScanParams *finishScanParams)
2997{
2998 WDI_Status status = WDI_STATUS_SUCCESS;
2999 WDI_FinishScanReqParamsType *wdiFinishScanParams =
3000 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
3001 sizeof(WDI_FinishScanReqParamsType)) ;
3002 tWDA_ReqParams *pWdaParams ;
3003 tANI_U8 i = 0;
3004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3005 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 if(NULL == wdiFinishScanParams)
3007 {
3008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3009 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3010 VOS_ASSERT(0);
3011 return VOS_STATUS_E_NOMEM;
3012 }
3013 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3014 if(NULL == pWdaParams)
3015 {
3016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3017 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3018 VOS_ASSERT(0);
3019 vos_mem_free(wdiFinishScanParams);
3020 return VOS_STATUS_E_NOMEM;
3021 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3022 /* Copy init Scan params to WDI structure */
3023 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3024 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3025 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3027 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3028 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3029 finishScanParams->frameLength ;
3030 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3031 finishScanParams->currentOperChannel ;
3032 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3033 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3034 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3035 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3036 {
3037 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3038 finishScanParams->scanEntry.bssIdx[i] ;
3039 }
3040
3041
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3042 /* if Frame length, copy macMgmtHdr ro WDI structure */
3043 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3044 {
3045 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3046 &finishScanParams->macMgmtHdr,
3047 sizeof(WDI_MacMgmtHdr)) ;
3048 }
3049 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3050 /* Store Init Req pointer, as this will be used for response */
3051 /* store Params pass it to WDI */
3052 pWdaParams->pWdaContext = pWDA;
3053 pWdaParams->wdaMsgParam = finishScanParams;
3054 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3055 /* call DAL API to pass init scan request to DAL */
3056 status = WDI_FinishScanReq(wdiFinishScanParams,
3057 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3058
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3059
3060 /*
3061 * WDI API returns failure..
3062 */
3063 if(IS_WDI_STATUS_FAILURE( status))
3064 {
3065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3066 "Failure in Finish Scan WDI API, free all the memory " );
3067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3068 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3069 finishScanParams->status = eSIR_FAILURE ;
3070 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3071 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3072 return CONVERT_WDI2VOS_STATUS(status) ;
3073}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3074/*---------------------------------------------------------------------
3075 * ASSOC API's
3076 *---------------------------------------------------------------------
3077 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3078/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3079 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3080 * Trigger Init SCAN callback
3081 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3082void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3083{
3084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3085 tWDA_CbContext *pWDA;
3086 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3088 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 if(NULL == pWdaParams)
3090 {
3091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3092 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3093 VOS_ASSERT(0) ;
3094 return ;
3095 }
3096 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3097 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3098 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3099 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3100 /* reset macBSSID */
3101 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3102 /* reset macSTASelf */
3103 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3104 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3105 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3106 return ;
3107}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3108
3109/*
3110 * FUNCTION: WDA_JoinReqCallback
3111 * Free memory and send SWITCH CHANNEL RSP back to PE.
3112 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3113 */
3114void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3115{
3116 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3117 tWDA_CbContext *pWDA;
3118 tSwitchChannelParams *joinReqParam;
3119
3120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3121 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3122
3123 if(NULL == pWdaParams)
3124 {
3125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3126 "%s: pWdaParams received NULL", __func__);
3127 VOS_ASSERT(0);
3128 return;
3129 }
3130
3131 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3132 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3133 joinReqParam->status = wdiStatus;
3134
3135 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3136 {
3137 /* reset macBSSID */
3138 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3139 /* reset macSTASelf */
3140 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3141
3142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3143 vos_mem_free(pWdaParams);
3144 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3145 }
3146
3147 return;
3148}
3149
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3150/*
3151 * FUNCTION: WDA_ProcessJoinReq
3152 * Trigger Join REQ in WDI
3153 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3155 tSwitchChannelParams* joinReqParam)
3156{
3157 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3158 WDI_JoinReqParamsType *wdiJoinReqParam =
3159 (WDI_JoinReqParamsType *)vos_mem_malloc(
3160 sizeof(WDI_JoinReqParamsType)) ;
3161 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3163 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3164 if(NULL == wdiJoinReqParam)
3165 {
3166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3167 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3168 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3169 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3170 return VOS_STATUS_E_NOMEM;
3171 }
3172 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3173 if(NULL == pWdaParams)
3174 {
3175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3176 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3177 VOS_ASSERT(0);
3178 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3179 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3180 return VOS_STATUS_E_NOMEM;
3181 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3182
3183 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3184 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3185 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3186 {
3187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3188 "%s: received join request when BSSID or self-STA is NULL "
3189 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3190 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3191 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3192 VOS_ASSERT(0);
3193 vos_mem_free(wdiJoinReqParam);
3194 vos_mem_free(pWdaParams);
3195 joinReqParam->status = eSIR_FAILURE ;
3196 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3197 return VOS_STATUS_E_INVAL;
3198 }
3199
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3200 /* copy the BSSID for pWDA */
3201 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3202 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3203 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3204 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3205 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3206 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3207#ifdef WLAN_FEATURE_VOWIFI
3208 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3209 joinReqParam->maxTxPower ;
3210#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3211 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3212 joinReqParam->localPowerConstraint ;
3213#endif
3214 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3215 joinReqParam->secondaryChannelOffset ;
3216 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3217
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3218 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3219 wdiJoinReqParam->pUserData = pWdaParams;
3220
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3221 /* Store Init Req pointer, as this will be used for response */
3222 /* store Params pass it to WDI */
3223 pWdaParams->pWdaContext = pWDA;
3224 pWdaParams->wdaMsgParam = joinReqParam;
3225 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3226 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3227 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3228 if(IS_WDI_STATUS_FAILURE(status))
3229 {
3230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3231 "Failure in Join WDI API, free all the memory " );
3232 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3233 vos_mem_free(pWdaParams) ;
3234 joinReqParam->status = eSIR_FAILURE ;
3235 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3237 return CONVERT_WDI2VOS_STATUS(status) ;
3238}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239/*
3240 * FUNCTION: WDA_SwitchChannelReqCallback
3241 * send Switch channel RSP back to PE
3242 */
3243void WDA_SwitchChannelReqCallback(
3244 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3245{
3246 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3247 tWDA_CbContext *pWDA;
3248 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3250 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3251 if(NULL == pWdaParams)
3252 {
3253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3254 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3255 VOS_ASSERT(0) ;
3256 return ;
3257 }
3258 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3259 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3260
3261#ifdef WLAN_FEATURE_VOWIFI
3262 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3263#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3264 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3265 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3266 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3267 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3268 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3269 return ;
3270}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3271/*
3272 * FUNCTION: WDA_ProcessChannelSwitchReq
3273 * Request to WDI to switch channel REQ params.
3274 */
3275VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3276 tSwitchChannelParams *pSwitchChanParams)
3277{
3278 WDI_Status status = WDI_STATUS_SUCCESS ;
3279 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3280 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3281 sizeof(WDI_SwitchChReqParamsType)) ;
3282 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3284 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 if(NULL == wdiSwitchChanParam)
3286 {
3287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3288 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3289 VOS_ASSERT(0);
3290 return VOS_STATUS_E_NOMEM;
3291 }
3292 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3293 if(NULL == pWdaParams)
3294 {
3295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3296 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3297 VOS_ASSERT(0);
3298 vos_mem_free(wdiSwitchChanParam);
3299 return VOS_STATUS_E_NOMEM;
3300 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3301 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3302#ifndef WLAN_FEATURE_VOWIFI
3303 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3304 pSwitchChanParams->localPowerConstraint;
3305#endif
3306 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3307 pSwitchChanParams->secondaryChannelOffset;
3308 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3309 /* Store req pointer, as this will be used for response */
3310 /* store Params pass it to WDI */
3311 pWdaParams->pWdaContext = pWDA;
3312 pWdaParams->wdaMsgParam = pSwitchChanParams;
3313 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3314#ifdef WLAN_FEATURE_VOWIFI
3315 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3316 = pSwitchChanParams->maxTxPower;
3317 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3318 pSwitchChanParams ->selfStaMacAddr,
3319 sizeof(tSirMacAddr));
3320#endif
3321 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3322 pSwitchChanParams->bssId,
3323 sizeof(tSirMacAddr));
3324
3325 status = WDI_SwitchChReq(wdiSwitchChanParam,
3326 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3327 if(IS_WDI_STATUS_FAILURE(status))
3328 {
3329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3330 "Failure in process channel switch Req WDI API, free all the memory " );
3331 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3332 vos_mem_free(pWdaParams) ;
3333 pSwitchChanParams->status = eSIR_FAILURE ;
3334 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3335 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3336 return CONVERT_WDI2VOS_STATUS(status) ;
3337}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3338
3339/*
3340 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3341 * send Switch channel RSP back to PE
3342 */
3343void WDA_SwitchChannelReqCallback_V1(
3344 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3345 void* pUserData)
3346{
3347 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3348 tWDA_CbContext *pWDA;
3349 tSwitchChannelParams *pSwitchChanParams;
3350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3351 "<------ %s " ,__func__);
3352
3353 if (NULL == pWdaParams)
3354 {
3355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3356 "%s: pWdaParams received NULL", __func__);
3357 VOS_ASSERT(0);
3358 return ;
3359 }
3360 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3361 pSwitchChanParams =
3362 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3363 pSwitchChanParams->channelSwitchSrc =
3364 wdiSwitchChanRsp->channelSwitchSrc;
3365#ifdef WLAN_FEATURE_VOWIFI
3366 pSwitchChanParams->txMgmtPower =
3367 wdiSwitchChanRsp->ucTxMgmtPower;
3368#endif
3369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3370 vos_mem_free(pWdaParams);
3371 pSwitchChanParams->status =
3372 wdiSwitchChanRsp->wdiStatus ;
3373 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3374 (void *)pSwitchChanParams , 0);
3375 return;
3376}
3377
3378/*
3379 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3380 * Request to WDI to switch channel REQ params.
3381 */
3382VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3383 tSwitchChannelParams *pSwitchChanParams)
3384{
3385 WDI_Status status = WDI_STATUS_SUCCESS ;
3386 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3387 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3388 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3389 tWDA_ReqParams *pWdaParams ;
3390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3391 "------> %s " ,__func__);
3392 if (NULL == wdiSwitchChanParam)
3393 {
3394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3395 "%s: VOS MEM Alloc Failure", __func__);
3396 VOS_ASSERT(0);
3397 return VOS_STATUS_E_NOMEM;
3398 }
3399 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3400 if (NULL == pWdaParams)
3401 {
3402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3403 "%s: VOS MEM Alloc Failure", __func__);
3404 VOS_ASSERT(0);
3405 vos_mem_free(wdiSwitchChanParam);
3406 return VOS_STATUS_E_NOMEM;
3407 }
3408 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3409 pSwitchChanParams->channelSwitchSrc;
3410
3411 wdiSwitchChanParam->wdiChInfo.ucChannel =
3412 pSwitchChanParams->channelNumber;
3413#ifndef WLAN_FEATURE_VOWIFI
3414 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3415 pSwitchChanParams->localPowerConstraint;
3416#endif
3417 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3418 pSwitchChanParams->secondaryChannelOffset;
3419 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3420 /* Store req pointer, as this will be used for response */
3421 /* store Params pass it to WDI */
3422 pWdaParams->pWdaContext = pWDA;
3423 pWdaParams->wdaMsgParam = pSwitchChanParams;
3424 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3425#ifdef WLAN_FEATURE_VOWIFI
3426 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3427 pSwitchChanParams->maxTxPower;
3428 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3429 pSwitchChanParams ->selfStaMacAddr,
3430 sizeof(tSirMacAddr));
3431#endif
3432 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3433 pSwitchChanParams->bssId,
3434 sizeof(tSirMacAddr));
3435
3436 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3437 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3438 pWdaParams);
3439 if (IS_WDI_STATUS_FAILURE(status))
3440 {
3441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3442 "Failure in process channel switch Req WDI "
3443 "API, free all the memory " );
3444 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3445 vos_mem_free(pWdaParams) ;
3446 pSwitchChanParams->status = eSIR_FAILURE ;
3447 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3448 (void *)pSwitchChanParams, 0) ;
3449 }
3450 return CONVERT_WDI2VOS_STATUS(status) ;
3451}
3452
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3453/*
3454 * FUNCTION: WDA_ConfigBssReqCallback
3455 * config BSS Req Callback, called by WDI
3456 */
3457void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3458 ,void* pUserData)
3459{
3460 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3461 tWDA_CbContext *pWDA;
3462 tAddBssParams *configBssReqParam;
3463 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3465 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 if(NULL == pWdaParams)
3467 {
3468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3469 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3470 VOS_ASSERT(0) ;
3471 return ;
3472 }
3473 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3474 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3475 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3476 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3477 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3478 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3479 {
3480 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3481 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3482 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3483 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3484 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3485
3486 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3487 {
3488 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3489 {
3490 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3491 staConfigBssParam->staType = STA_ENTRY_BSSID;
3492 }
3493 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3494 (staConfigBssParam->staType == STA_ENTRY_SELF))
3495 {
3496 /* This is the 1st add BSS Req for the BTAMP STA */
3497 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3498 staConfigBssParam->staType = STA_ENTRY_BSSID;
3499 }
3500 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3501 (staConfigBssParam->staType == STA_ENTRY_PEER))
3502 {
3503 /* This is the 2nd ADD BSS Request that is sent
3504 * on the BTAMP STA side. The Sta type is
3505 * set to STA_ENTRY_PEER here.*/
3506 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3507 }
3508 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3509 (staConfigBssParam->staType == STA_ENTRY_SELF))
3510 {
3511 /* statype is already set by PE.
3512 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3513 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3514 staConfigBssParam->staType = STA_ENTRY_BSSID;
3515 }
3516 else
3517 {
3518 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3519 staConfigBssParam->staType = STA_ENTRY_PEER;
3520 }
3521 }
3522 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3523 {
3524 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3525 staConfigBssParam->staType = STA_ENTRY_SELF;
3526 }
3527 else
3528 {
3529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3530 "Invalid operation mode specified");
3531 VOS_ASSERT(0);
3532 }
3533
3534 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3535 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3536 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3537 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3538 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3539 sizeof(tSirMacAddr));
3540 staConfigBssParam->txChannelWidthSet =
3541 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3542 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3543 staConfigBssParam->htCapable)
3544 {
3545 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3546 wdiConfigBssRsp->ucBSSIdx;
3547 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3548 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]3549 pWDA->wdaStaInfo[staConfigBssParam->staIdx].currentOperChan =
3550 configBssReqParam->currentOperChannel;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3552 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3553 wdiConfigBssRsp->ucBSSIdx,
3554 wdiConfigBssRsp->ucSTAIdx))
3555 {
3556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3557 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 VOS_ASSERT(0) ;
3559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3560 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3561 {
3562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3563 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3564 VOS_ASSERT(0) ;
3565 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3566#ifdef WLAN_FEATURE_VOWIFI
3567 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3568#endif
3569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3570 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3571 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3573 return ;
3574}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3575/*
3576 * FUNCTION: WDA_UpdateEdcaParamsForAC
3577 * Update WDI EDCA params with PE edca params
3578 */
3579void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3580 WDI_EdcaParamRecord *wdiEdcaParam,
3581 tSirMacEdcaParamRecord *macEdcaParam)
3582{
3583 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3584 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3585 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3586 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3587 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3588 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3589}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3590/*
3591 * FUNCTION: WDA_ProcessConfigBssReq
3592 * Configure BSS before starting Assoc with AP
3593 */
3594VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3595 tAddBssParams* configBssReqParam)
3596{
3597 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3598 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3599 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3601 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3602 if (NULL == configBssReqParam)
3603 {
3604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3605 "%s: configBssReqParam is NULL", __func__);
3606 return VOS_STATUS_E_INVAL;
3607 }
3608
3609 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3610 sizeof(WDI_ConfigBSSReqParamsType)) ;
3611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3612 if(NULL == wdiConfigBssReqParam)
3613 {
3614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3615 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3616 VOS_ASSERT(0);
3617 return VOS_STATUS_E_NOMEM;
3618 }
3619 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3620 if(NULL == pWdaParams)
3621 {
3622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3623 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3624 VOS_ASSERT(0);
3625 vos_mem_free(wdiConfigBssReqParam);
3626 return VOS_STATUS_E_NOMEM;
3627 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3629 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3630 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3631 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3632 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633 /* Store Init Req pointer, as this will be used for response */
3634 /* store Params pass it to WDI */
3635 pWdaParams->pWdaContext = pWDA;
3636 pWdaParams->wdaMsgParam = configBssReqParam;
3637 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3638 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3639 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3640 if(IS_WDI_STATUS_FAILURE(status))
3641 {
3642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3643 "Failure in Config BSS WDI API, free all the memory " );
3644 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3645 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3646 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3647 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3649 return CONVERT_WDI2VOS_STATUS(status) ;
3650}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3651#ifdef ENABLE_HAL_COMBINED_MESSAGES
3652/*
3653 * FUNCTION: WDA_PostAssocReqCallback
3654 * Post ASSOC req callback, send RSP back to PE
3655 */
3656void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3657 void* pUserData)
3658{
3659 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3660 tPostAssocParams *postAssocReqParam =
3661 (tPostAssocParams *)pWDA->wdaMsgParam ;
3662 /*STA context within the BSS Params*/
3663 tAddStaParams *staPostAssocParam =
3664 &postAssocReqParam->addBssParams.staContext ;
3665 /*STA Params for self STA*/
3666 tAddStaParams *selfStaPostAssocParam =
3667 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3669 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3671 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3672 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3673 {
3674 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3675 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3676 sizeof(tSirMacAddr)) ;
3677 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3678 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3679 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3680 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3681 }
3682 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3683 pWDA->wdaWdiApiMsgParam = NULL;
3684 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3686 return ;
3687}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3688/*
3689 * FUNCTION: WDA_ProcessPostAssocReq
3690 * Trigger POST ASSOC processing in WDI
3691 */
3692VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3693 tPostAssocParams *postAssocReqParam)
3694{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3695 WDI_Status status = WDI_STATUS_SUCCESS ;
3696
3697 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3698 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3699 sizeof(WDI_PostAssocReqParamsType)) ;
3700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3701 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3702
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3703 if(NULL == wdiPostAssocReqParam)
3704 {
3705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3706 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3707 VOS_ASSERT(0);
3708 return VOS_STATUS_E_NOMEM;
3709 }
3710
3711 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3712 {
3713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3714 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3715 VOS_ASSERT(0);
3716 return VOS_STATUS_E_FAILURE;
3717 }
3718
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3719 /* update BSS params into WDI structure */
3720 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3721 &postAssocReqParam->addBssParams) ;
3722 /* update STA params into WDI structure */
3723 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3724 &postAssocReqParam->addStaParams) ;
3725
3726 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3727 postAssocReqParam->addBssParams.highPerformance;
3728 WDA_UpdateEdcaParamsForAC(pWDA,
3729 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3730 &postAssocReqParam->addBssParams.acbe);
3731 WDA_UpdateEdcaParamsForAC(pWDA,
3732 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3733 &postAssocReqParam->addBssParams.acbk);
3734 WDA_UpdateEdcaParamsForAC(pWDA,
3735 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3736 &postAssocReqParam->addBssParams.acvi);
3737 WDA_UpdateEdcaParamsForAC(pWDA,
3738 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3739 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3740 /* Store Init Req pointer, as this will be used for response */
3741 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3742 /* store Params pass it to WDI */
3743 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3744 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3745 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3746 if(IS_WDI_STATUS_FAILURE(status))
3747 {
3748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3749 "Failure in Post Assoc WDI API, free all the memory " );
3750 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3751 pWDA->wdaWdiApiMsgParam = NULL;
3752 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3753 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3754 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3755 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3756 return CONVERT_WDI2VOS_STATUS(status) ;
3757}
3758#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759/*
3760 * FUNCTION: WDA_AddStaReqCallback
3761 * ADD STA req callback, send RSP back to PE
3762 */
3763void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3764 void* pUserData)
3765{
3766 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3767 tWDA_CbContext *pWDA;
3768 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3770 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3771 if(NULL == pWdaParams)
3772 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,"%s: pWdaParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3774 VOS_ASSERT(0) ;
3775 return ;
3776 }
3777 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3778 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3779 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3780 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3781 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3782 {
3783 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3784 /*TODO: UMAC structure doesn't have these fields*/
3785 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3786 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3787 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3788 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3789 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3790 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3791#ifdef FEATURE_WLAN_TDLS
3792 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3793 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3794#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3795 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3796#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3797 {
3798 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3799 wdiConfigStaRsp->ucBssIdx;
3800 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3801 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]3802 pWDA->wdaStaInfo[addStaReqParam->staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3803 }
3804 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3805 {
3806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3807 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3808 VOS_ASSERT(0) ;
3809 return ;
3810 }
3811 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3812 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3813 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3814 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3815 return ;
3816}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3817/*
3818 * FUNCTION: WDA_ConfigStaReq
3819 * Trigger Config STA processing in WDI
3820 */
3821VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3822 tAddStaParams *addStaReqParam)
3823{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3824 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3825 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3826 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3827 sizeof(WDI_ConfigSTAReqParamsType)) ;
3828 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3830 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3831 if(NULL == wdiConfigStaReqParam)
3832 {
3833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3834 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3835 VOS_ASSERT(0);
3836 return VOS_STATUS_E_NOMEM;
3837 }
3838 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3839 if(NULL == pWdaParams)
3840 {
3841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3842 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3843 VOS_ASSERT(0);
3844 vos_mem_free(wdiConfigStaReqParam);
3845 return VOS_STATUS_E_NOMEM;
3846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3847 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3848 /* update STA params into WDI structure */
3849 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3850 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3851 /* Store Init Req pointer, as this will be used for response */
3852 /* store Params pass it to WDI */
3853 pWdaParams->pWdaContext = pWDA;
3854 pWdaParams->wdaMsgParam = addStaReqParam;
3855 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3856 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3857 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3858 if(IS_WDI_STATUS_FAILURE(status))
3859 {
3860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3861 "Failure in Config STA WDI API, free all the memory " );
3862 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3863 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3864 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3865 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3866 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3867 return CONVERT_WDI2VOS_STATUS(status) ;
3868}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3869/*
3870 * FUNCTION: WDA_DelBSSReqCallback
3871 * Dens DEL BSS RSP back to PE
3872 */
3873void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3874 void* pUserData)
3875{
3876 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3877 tWDA_CbContext *pWDA;
3878 tDeleteBssParams *delBssReqParam;
3879 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3881 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3882 if(NULL == pWdaParams)
3883 {
3884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3885 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3886 VOS_ASSERT(0) ;
3887 return ;
3888 }
3889 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3890 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3891 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3892 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3893 {
3894 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3895 sizeof(tSirMacAddr)) ;
3896 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3897 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3898 {
3899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3900 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3901 VOS_ASSERT(0) ;
3902 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3903 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3904 {
3905 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3906 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3907 VOS_ASSERT(0) ;
3908 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3909 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3910 {
3911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3912 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3913 VOS_ASSERT(0) ;
3914 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3915
3916 WLANTL_StartForwarding(staIdx,0,0);
3917
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3918 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3919 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3920 /* reset the the system role*/
3921 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3922
3923 /* Reset the BA related information */
3924 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3925 {
3926 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3927 {
3928 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3929 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]3930 pWDA->wdaStaInfo[staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3931 /* Reset framesTxed counters here */
3932 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3933 {
3934 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3935 }
3936 }
3937 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3938 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3939 return ;
3940}
3941
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3942/*
3943 * FUNCTION: WDA_ProcessDelBssReq
3944 * Init DEL BSS req with WDI
3945 */
3946VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3947 tDeleteBssParams *delBssParam)
3948{
3949 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3950 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3951 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3952 sizeof(WDI_DelBSSReqParamsType)) ;
3953 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3955 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3956 if(NULL == wdiDelBssReqParam)
3957 {
3958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3959 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 VOS_ASSERT(0);
3961 return VOS_STATUS_E_NOMEM;
3962 }
3963 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3964 if(NULL == pWdaParams)
3965 {
3966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3967 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3968 VOS_ASSERT(0);
3969 vos_mem_free(wdiDelBssReqParam);
3970 return VOS_STATUS_E_NOMEM;
3971 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3972 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3973 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3974
3975 /* Store Init Req pointer, as this will be used for response */
3976 /* store Params pass it to WDI */
3977 pWdaParams->pWdaContext = pWDA;
3978 pWdaParams->wdaMsgParam = delBssParam;
3979 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3980 status = WDI_DelBSSReq(wdiDelBssReqParam,
3981 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3982 if(IS_WDI_STATUS_FAILURE(status))
3983 {
3984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3985 "Failure in Del BSS WDI API, free all the memory " );
3986 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3987 vos_mem_free(pWdaParams) ;
3988 delBssParam->status = eSIR_FAILURE ;
3989 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3990 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3991 return CONVERT_WDI2VOS_STATUS(status) ;
3992}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3993/*
3994 * FUNCTION: WDA_DelSTAReqCallback
3995 * Dens DEL STA RSP back to PE
3996 */
3997void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3998 void* pUserData)
3999{
4000 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4001 tWDA_CbContext *pWDA;
4002 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4004 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4005 if(NULL == pWdaParams)
4006 {
4007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4008 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4009 VOS_ASSERT(0) ;
4010 return ;
4011 }
4012 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4013 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4014 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4015 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
4016 {
4017 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
4018 {
4019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4020 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4021 VOS_ASSERT(0) ;
4022 }
4023 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4024 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4025 }
4026 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4027 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4028 /*Reset the BA information corresponding to this STAIdx */
4029 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4030 WDA_INVALID_STA_INDEX;
4031 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]4032 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4033 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4034 return ;
4035}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4036/*
4037 * FUNCTION: WDA_ProcessDelStaReq
4038 * Init DEL STA req with WDI
4039 */
4040VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4041 tDeleteStaParams *delStaParam)
4042{
4043 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4044 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4045 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4046 sizeof(WDI_DelSTAReqParamsType)) ;
4047 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4049 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4050 if(NULL == wdiDelStaReqParam)
4051 {
4052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4053 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4054 VOS_ASSERT(0);
4055 return VOS_STATUS_E_NOMEM;
4056 }
4057 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4058 if(NULL == pWdaParams)
4059 {
4060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4061 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4062 VOS_ASSERT(0);
4063 vos_mem_free(wdiDelStaReqParam);
4064 return VOS_STATUS_E_NOMEM;
4065 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4066 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
4067 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4068 /* Store Init Req pointer, as this will be used for response */
4069 /* store Params pass it to WDI */
4070 pWdaParams->pWdaContext = pWDA;
4071 pWdaParams->wdaMsgParam = delStaParam;
4072 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4073 status = WDI_DelSTAReq(wdiDelStaReqParam,
4074 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4075 if(IS_WDI_STATUS_FAILURE(status))
4076 {
4077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4078 "Failure in Del STA WDI API, free all the memory status = %d",
4079 status );
4080 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4081 vos_mem_free(pWdaParams) ;
4082 delStaParam->status = eSIR_FAILURE ;
4083 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4084 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4085 return CONVERT_WDI2VOS_STATUS(status) ;
4086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4087void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
4088{
4089 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4090 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4091 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4093 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4094 if(NULL == pWdaParams)
4095 {
4096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4097 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4098 VOS_ASSERT(0) ;
4099 return ;
4100 }
4101 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4102 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4103 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4104 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4105 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4106 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4107 pwdiAddSTASelfRsp->macSelfSta,
4108 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4109 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4110 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4111 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4112 {
4113 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4114 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
4115 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4116 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4117 return ;
4118}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4120/*
4121 * FUNCTION: WDA_ProcessAddStaSelfReq
4122 *
4123 */
4124VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4125{
4126 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4127 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4128 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4129 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4130 sizeof(WDI_AddSTASelfReqParamsType)) ;
4131 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4133 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4134 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4135 if( NULL == wdiAddStaSelfReq )
4136 {
4137 VOS_ASSERT( 0 );
4138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4139 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4140 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4141 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4142 return( VOS_STATUS_E_NOMEM );
4143 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4144 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4145 if( NULL == pWdaParams )
4146 {
4147 VOS_ASSERT( 0 );
4148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4149 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4150 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4151 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4152 vos_mem_free(wdiAddStaSelfReq) ;
4153 return( VOS_STATUS_E_NOMEM );
4154 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4155 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4156 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4157 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4158 /* Store Init Req pointer, as this will be used for response */
4159 /* store Params pass it to WDI */
4160 pWdaParams->pWdaContext = pWDA;
4161 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4162 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4163 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4164
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4165 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4166 {
4167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4168 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4169 wstatus );
4170 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4171 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4172 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4173 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4174 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4175 pAddStaSelfReq->status = eSIR_FAILURE ;
4176 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4177 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4178 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4179}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4180/*
4181 * FUNCTION: WDA_DelSTASelfRespCallback
4182 *
4183 */
4184void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4185 wdiDelStaSelfRspParams , void* pUserData)
4186{
4187 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4188 tWDA_CbContext *pWDA;
4189 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4191 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4192 if (NULL == pWdaParams)
4193 {
4194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4195 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4196 VOS_ASSERT(0);
4197 return;
4198 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4199 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4200 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4201 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4202 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4203
4204 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4205 vos_mem_free(pWdaParams) ;
4206
4207 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4208 return ;
4209}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4210/*
4211 * FUNCTION: WDA_DelSTASelfReqCallback
4212 *
4213 */
4214void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4215 void* pUserData)
4216{
4217 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4218 tWDA_CbContext *pWDA;
4219 tDelStaSelfParams *delStaSelfParams;
4220
4221 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4222 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4223 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4224
4225 if (NULL == pWdaParams)
4226 {
4227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4228 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4229 VOS_ASSERT(0);
4230 return;
4231 }
4232
4233 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4234 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4235
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4236 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4237
4238 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4239 {
4240 VOS_ASSERT(0);
4241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4242 vos_mem_free(pWdaParams) ;
4243 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4244 }
4245
4246 return ;
4247}
4248
4249/*
4250 * FUNCTION: WDA_DelSTASelfReq
4251 * Trigger Config STA processing in WDI
4252 */
4253VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4254 tDelStaSelfParams* pDelStaSelfReqParam)
4255{
4256 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4257 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4258 tWDA_ReqParams *pWdaParams = NULL;
4259 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4260 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4261 sizeof(WDI_DelSTASelfReqParamsType)) ;
4262
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4264 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4265 if( NULL == wdiDelStaSelfReq )
4266 {
4267 VOS_ASSERT( 0 );
4268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4269 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4270 return( VOS_STATUS_E_NOMEM );
4271 }
4272
4273 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4274 if( NULL == pWdaParams )
4275 {
4276 VOS_ASSERT( 0 );
4277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4278 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4279 vos_mem_free(wdiDelStaSelfReq) ;
4280 return( VOS_STATUS_E_NOMEM );
4281 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4282 pWdaParams->pWdaContext = pWDA;
4283 /* Store param pointer as passed in by caller */
4284 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4285 /* store Params pass it to WDI */
4286 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4287 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4288 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4289
4290 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4291 wdiDelStaSelfReq->pUserData = pWdaParams;
4292
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4293 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4294 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4295
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4296 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4297 {
4298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4299 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4300 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4301 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4302 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4303 vos_mem_free(pWdaParams) ;
4304 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4305 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4306 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4307 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4308}
4309
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4310/*
4311 * FUNCTION: WDA_SendMsg
4312 * Send Message back to PE
4313 */
4314void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4315 void *pBodyptr, tANI_U32 bodyVal)
4316{
4317 tSirMsgQ msg = {0} ;
4318 tANI_U32 status = VOS_STATUS_SUCCESS ;
4319 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4320 msg.type = msgType;
4321 msg.bodyval = bodyVal;
4322 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4323 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4324 if (VOS_STATUS_SUCCESS != status)
4325 {
4326 if(NULL != pBodyptr)
4327 {
4328 vos_mem_free(pBodyptr);
4329 }
4330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4331 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4332 VOS_ASSERT(0) ;
4333 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4334 return ;
4335}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4336/*
4337 * FUNCTION: WDA_UpdateBSSParams
4338 * Translated WDA/PE BSS info into WDI BSS info..
4339 */
4340void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4341 WDI_ConfigBSSReqInfoType *wdiBssParams,
4342 tAddBssParams *wdaBssParams)
4343{
4344 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4345 /* copy bssReq Params to WDI structure */
4346 vos_mem_copy(wdiBssParams->macBSSID,
4347 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4348 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4349 sizeof(tSirMacAddr)) ;
4350 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4351 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4352 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4353 wdiBssParams->ucShortSlotTimeSupported =
4354 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4355 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4356 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4357 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4358 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4359 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4360
4361 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4362 wdiBssParams->ucTXOPProtectionFullSupport =
4363 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4364 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4365 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4366 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4367 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4368 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4369 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4370 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4371
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4372 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4373
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4374 /* copy SSID into WDI structure */
4375 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4376 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4377 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4378 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4379 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4380 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4381#ifdef WLAN_FEATURE_VOWIFI
4382 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4383#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4384 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4385 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4386#ifdef WLAN_FEATURE_VOWIFI_11R
4387 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4388 if(wdiBssParams->bExtSetStaKeyParamValid)
4389 {
4390 /* copy set STA key params to WDI structure */
4391 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4392 wdaBssParams->extSetStaKeyParam.staIdx;
4393 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4394 wdaBssParams->extSetStaKeyParam.encType;
4395 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4396 wdaBssParams->extSetStaKeyParam.wepType;
4397 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4398 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4399 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4400 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4401 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4402 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4403 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4404 {
4405 WDA_GetWepKeysFromCfg( pWDA,
4406 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4407 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4408 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4409 }
4410 else
4411 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4412 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4413 keyIndex++)
4414 {
4415 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4416 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4417 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4418 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4419 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4420 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4421 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4422 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4423 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4424 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4425 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4426 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4427 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4428 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4429 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4430 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4431 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4432 }
4433 }
4434 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4435 }
4436 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4437 {
4438 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4439 sizeof(wdaBssParams->extSetStaKeyParam) );
4440 }
4441#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4442#ifdef WLAN_FEATURE_11AC
4443 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4444 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4445#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4446
4447 return ;
4448}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4449/*
4450 * FUNCTION: WDA_UpdateSTAParams
4451 * Translated WDA/PE BSS info into WDI BSS info..
4452 */
4453void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4454 WDI_ConfigStaReqInfoType *wdiStaParams,
4455 tAddStaParams *wdaStaParams)
4456{
4457 tANI_U8 i = 0;
4458 /* Update STA params */
4459 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4460 sizeof(tSirMacAddr)) ;
4461 wdiStaParams->usAssocId = wdaStaParams->assocId;
4462 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4463 wdiStaParams->staIdx = wdaStaParams->staIdx;
4464
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4465 wdiStaParams->ucShortPreambleSupported =
4466 wdaStaParams->shortPreambleSupported;
4467 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4468 sizeof(tSirMacAddr)) ;
4469 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4470
4471 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4472
4473 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4474 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4475 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4476 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4477 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4478 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4479 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4480
4481 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4482 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4483 wdiStaParams->wdiSupportedRates.opRateMode =
4484 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4485 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4486 {
4487 wdiStaParams->wdiSupportedRates.llbRates[i] =
4488 wdaStaParams->supportedRates.llbRates[i];
4489 }
4490 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4491 {
4492 wdiStaParams->wdiSupportedRates.llaRates[i] =
4493 wdaStaParams->supportedRates.llaRates[i];
4494 }
4495 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4496 {
4497 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4498 wdaStaParams->supportedRates.aniLegacyRates[i];
4499 }
4500 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4501 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4502#ifdef WLAN_FEATURE_11AC
4503 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4504 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4505 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4506 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4507#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4508 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4509 {
4510 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4511 wdaStaParams->supportedRates.supportedMCSSet[i];
4512 }
4513 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4514 wdaStaParams->supportedRates.rxHighestDataRate;
4515
4516 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4517
4518 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4519
4520 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4521 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4522 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4523
4524 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4525 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4526 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4527 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4528 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4529#ifdef WLAN_FEATURE_11AC
4530 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4531 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4532 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4533 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4534 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4535 * must be set by default */
4536 if ( wdiStaParams->vhtTxMUBformeeCapable )
4537 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4538#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4539 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4540 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4541 return ;
4542}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4543/*
4544 * -------------------------------------------------------------------------
4545 * CFG update to WDI
4546 * -------------------------------------------------------------------------
4547 */
4548
4549 /*
4550 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4551 * Convert the WNI CFG ID to HAL CFG ID
4552 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4553static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4554{
4555 switch(wniCfgId)
4556 {
4557 case WNI_CFG_STA_ID:
4558 return QWLAN_HAL_CFG_STA_ID;
4559 case WNI_CFG_CURRENT_TX_ANTENNA:
4560 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4561 case WNI_CFG_CURRENT_RX_ANTENNA:
4562 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4563 case WNI_CFG_LOW_GAIN_OVERRIDE:
4564 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4565 case WNI_CFG_POWER_STATE_PER_CHAIN:
4566 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4567 case WNI_CFG_CAL_PERIOD:
4568 return QWLAN_HAL_CFG_CAL_PERIOD;
4569 case WNI_CFG_CAL_CONTROL:
4570 return QWLAN_HAL_CFG_CAL_CONTROL;
4571 case WNI_CFG_PROXIMITY:
4572 return QWLAN_HAL_CFG_PROXIMITY;
4573 case WNI_CFG_NETWORK_DENSITY:
4574 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4575 case WNI_CFG_MAX_MEDIUM_TIME:
4576 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4577 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4578 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4579 case WNI_CFG_RTS_THRESHOLD:
4580 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4581 case WNI_CFG_SHORT_RETRY_LIMIT:
4582 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4583 case WNI_CFG_LONG_RETRY_LIMIT:
4584 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4585 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4586 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4587 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4588 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4589 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4590 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4591 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4592 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4593 case WNI_CFG_FIXED_RATE:
4594 return QWLAN_HAL_CFG_FIXED_RATE;
4595 case WNI_CFG_RETRYRATE_POLICY:
4596 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4597 case WNI_CFG_RETRYRATE_SECONDARY:
4598 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4599 case WNI_CFG_RETRYRATE_TERTIARY:
4600 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4601 case WNI_CFG_FORCE_POLICY_PROTECTION:
4602 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4603 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4604 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4605 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4606 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4607 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4608 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4609 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4610 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4611 case WNI_CFG_MAX_BA_SESSIONS:
4612 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4613 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4614 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4615 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4616 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4617 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4618 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4619 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4620 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4621 case WNI_CFG_STATS_PERIOD:
4622 return QWLAN_HAL_CFG_STATS_PERIOD;
4623 case WNI_CFG_CFP_MAX_DURATION:
4624 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4625#if 0 /*This is not part of CFG*/
4626 case WNI_CFG_FRAME_TRANS_ENABLED:
4627 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4628#endif
4629 case WNI_CFG_DTIM_PERIOD:
4630 return QWLAN_HAL_CFG_DTIM_PERIOD;
4631 case WNI_CFG_EDCA_WME_ACBK:
4632 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4633 case WNI_CFG_EDCA_WME_ACBE:
4634 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4635 case WNI_CFG_EDCA_WME_ACVI:
4636 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4637 case WNI_CFG_EDCA_WME_ACVO:
4638 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4639#if 0
4640 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4641 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4642 case WNI_CFG_TELE_BCN_TRANS_LI:
4643 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4644 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4645 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4646 case WNI_CFG_TELE_BCN_MAX_LI:
4647 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4648 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4649 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4650#endif
4651 case WNI_CFG_ENABLE_CLOSE_LOOP:
4652 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4653 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4654 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4655 default:
4656 {
4657 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4658 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4659 wniCfgId);
4660 return VOS_STATUS_E_INVAL;
4661 }
4662 }
4663}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4664/*
4665 * FUNCTION: WDA_UpdateCfgCallback
4666 *
4667 */
4668void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4669{
4670 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4671 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4672 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
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 /*
4676 * currently there is no response message is expected between PE and
4677 * WDA, Failure return from WDI is a ASSERT condition
4678 */
4679 if(WDI_STATUS_SUCCESS != wdiStatus)
4680 {
4681 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4682 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4683 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4684 }
4685
4686 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4687 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4688 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4689 return ;
4690}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4691/*
4692 * FUNCTION: WDA_UpdateCfg
4693 *
4694 */
4695VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4696{
4697
4698 WDI_Status status = WDI_STATUS_SUCCESS ;
4699 tANI_U32 val =0;
4700 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4701 tHalCfg *configData;
4702 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4703 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4705 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4706 if (NULL == pMac )
4707 {
4708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4709 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4710 return VOS_STATUS_E_FAILURE;
4711 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4712 if(WDA_START_STATE != pWDA->wdaState)
4713 {
4714 return VOS_STATUS_E_FAILURE;
4715 }
4716
4717 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4718 {
4719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4720 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4721 VOS_ASSERT(0);
4722 return VOS_STATUS_E_FAILURE;
4723 }
4724
4725 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4726 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4727 if(NULL == wdiCfgReqParam)
4728 {
4729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4730 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4731 VOS_ASSERT(0);
4732 return VOS_STATUS_E_NOMEM;
4733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4734 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4735 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4736 if(NULL == wdiCfgReqParam->pConfigBuffer)
4737 {
4738 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4739 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4740 vos_mem_free(wdiCfgReqParam);
4741 VOS_ASSERT(0);
4742 return VOS_STATUS_E_NOMEM;
4743 }
4744
4745 /*convert the WNI CFG Id to HAL CFG Id*/
4746 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4747 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4748
4749 /*TODO: revisit this for handling string parameters */
4750 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4751 &val) != eSIR_SUCCESS)
4752 {
4753 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4754 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4755 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4756 vos_mem_free(wdiCfgReqParam);
4757 return eSIR_FAILURE;
4758 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4759 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4760 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4761 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4762 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4763 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4764
4765 /* store Params pass it to WDI */
4766 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4767#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4768 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4769 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4770 if(IS_WDI_STATUS_FAILURE(status))
4771 {
4772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4773 "Failure in Update CFG WDI API, free all the memory " );
4774 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4775 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4776 pWDA->wdaWdiCfgApiMsgParam = NULL;
4777 /* Failure is not expected */
4778 VOS_ASSERT(0) ;
4779 }
4780#else
4781 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4782 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4783 pWDA->wdaWdiCfgApiMsgParam = NULL;
4784#endif
4785 return CONVERT_WDI2VOS_STATUS(status) ;
4786}
4787
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4788VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4789 v_U8_t *pDefaultKeyId,
4790 v_U8_t *pNumKeys,
4791 WDI_KeysType *pWdiKeys )
4792{
4793 v_U32_t i, j, defKeyId = 0;
4794 v_U32_t val = SIR_MAC_KEY_LENGTH;
4795 VOS_STATUS status = WDI_STATUS_SUCCESS;
4796 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4797 if (NULL == pMac )
4798 {
4799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4800 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4801 return VOS_STATUS_E_FAILURE;
4802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4803 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4804 &defKeyId ))
4805 {
4806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4807 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4808 }
4809
4810 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4811 /* Need to extract ALL of the configured WEP Keys */
4812 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4813 {
4814 val = SIR_MAC_KEY_LENGTH;
4815 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4816 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4817 pWdiKeys[j].key,
4818 &val ))
4819 {
4820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4821 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4822 }
4823 else
4824 {
4825 pWdiKeys[j].keyId = (tANI_U8) i;
4826 /*
4827 * Actually, a DC (Don't Care) because
4828 * this is determined (and set) by PE/MLME
4829 */
4830 pWdiKeys[j].unicast = 0;
4831 /*
4832 * Another DC (Don't Care)
4833 */
4834 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4835 /* Another DC (Don't Care). Unused for WEP */
4836 pWdiKeys[j].paeRole = 0;
4837 /* Determined from wlan_cfgGetStr() above.*/
4838 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4839 j++;
4840 *pNumKeys = (tANI_U8) j;
4841 }
4842 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4843 return status;
4844}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4845/*
4846 * FUNCTION: WDA_SetBssKeyReqCallback
4847 * send SET BSS key RSP back to PE
4848 */
4849void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4850{
4851 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4852 tWDA_CbContext *pWDA;
4853 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4855 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4856 if(NULL == pWdaParams)
4857 {
4858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4859 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4860 VOS_ASSERT(0) ;
4861 return ;
4862 }
4863 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4864 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4865 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4866 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4867 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4868 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4869 return ;
4870}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871/*
4872 * FUNCTION: WDA_ProcessSetBssKeyReq
4873 * Request to WDI for programming the BSS key( key for
4874 * broadcast/multicast frames Encryption)
4875 */
4876VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4877 tSetBssKeyParams *setBssKeyParams )
4878{
4879 WDI_Status status = WDI_STATUS_SUCCESS ;
4880 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4881 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4882 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4883 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4884 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4886 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4887 if(NULL == wdiSetBssKeyParam)
4888 {
4889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4890 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4891 VOS_ASSERT(0);
4892 return VOS_STATUS_E_NOMEM;
4893 }
4894 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4895 if(NULL == pWdaParams)
4896 {
4897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4898 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4899 VOS_ASSERT(0);
4900 vos_mem_free(wdiSetBssKeyParam);
4901 return VOS_STATUS_E_NOMEM;
4902 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4903 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4904 /* copy set BSS params to WDI structure */
4905 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4906 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4907 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4908 if(setBssKeyParams->encType != eSIR_ED_NONE)
4909 {
4910 if( setBssKeyParams->numKeys == 0 &&
4911 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4912 setBssKeyParams->encType == eSIR_ED_WEP104))
4913 {
4914 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4915 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4916 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4917 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4918 }
4919 else
4920 {
4921 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4922 {
4923 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4924 setBssKeyParams->key[keyIndex].keyId;
4925 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4926 setBssKeyParams->key[keyIndex].unicast;
4927 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4928 setBssKeyParams->key[keyIndex].keyDirection;
4929 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4930 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4931 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4932 setBssKeyParams->key[keyIndex].paeRole;
4933 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4934 setBssKeyParams->key[keyIndex].keyLength;
4935 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4936 setBssKeyParams->key[keyIndex].key,
4937 SIR_MAC_MAX_KEY_LENGTH);
4938 }
4939 }
4940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4941 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4942 setBssKeyParams->singleTidRc;
4943 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4944 /* Store set key pointer, as this will be used for response */
4945 /* store Params pass it to WDI */
4946 pWdaParams->pWdaContext = pWDA;
4947 pWdaParams->wdaMsgParam = setBssKeyParams;
4948 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4949 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4950 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4951
4952 if(IS_WDI_STATUS_FAILURE(status))
4953 {
4954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4955 "Failure in Set BSS Key Req WDI API, free all the memory " );
4956 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4957 vos_mem_free(pWdaParams) ;
4958 setBssKeyParams->status = eSIR_FAILURE ;
4959 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4960 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4961 return CONVERT_WDI2VOS_STATUS(status) ;
4962}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963/*
4964 * FUNCTION: WDA_RemoveBssKeyReqCallback
4965 * send SET BSS key RSP back to PE
4966 */
4967void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4968{
4969 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4970 tWDA_CbContext *pWDA;
4971 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4973 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4974 if(NULL == pWdaParams)
4975 {
4976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4977 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4978 VOS_ASSERT(0) ;
4979 return ;
4980 }
4981 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4982 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4983 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4984 vos_mem_free(pWdaParams) ;
4985
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4986 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4987 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4988 return ;
4989}
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]4990
4991/*
4992 * FUNCTION: WDA_SpoofMacAddrRspCallback
4993 * recieves spoof mac addr response from FW
4994 */
4995void WDA_SpoofMacAddrRspCallback(WDI_SpoofMacAddrRspParamType* wdiRsp, void* pUserData)
4996{
4997 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4998 tWDA_CbContext *pWDA;
4999 tSirSpoofMacAddrReq *spoofMacAddrReq;
5000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5001 "<------ %s " ,__func__);
5002 if(NULL == pWdaParams)
5003 {
5004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5005 "%s: pWdaParams received NULL", __func__);
5006 VOS_ASSERT(0) ;
5007 return ;
5008 }
5009
5010 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5011 spoofMacAddrReq = (tSirSpoofMacAddrReq *)pWdaParams->wdaMsgParam ;
5012
5013 if(wdiRsp->wdiStatus != WDI_STATUS_SUCCESS )
5014 {
5015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5016 "%s: Unable to set Random Mac Addr in FW", __func__);
5017 }
5018
5019 vos_mem_free(spoofMacAddrReq);
5020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5021 vos_mem_free(pWdaParams);
5022 return ;
5023}
5024
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5025/*
5026 * FUNCTION: WDA_ProcessRemoveBssKeyReq
5027 * Request to WDI to remove the BSS key( key for broadcast/multicast
5028 * frames Encryption)
5029 */
5030VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
5031 tRemoveBssKeyParams *removeBssKeyParams )
5032{
5033 WDI_Status status = WDI_STATUS_SUCCESS ;
5034 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
5035 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
5036 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
5037 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5039 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5040 if(NULL == wdiRemoveBssKeyParam)
5041 {
5042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5043 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5044 VOS_ASSERT(0);
5045 return VOS_STATUS_E_NOMEM;
5046 }
5047 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5048 if(NULL == pWdaParams)
5049 {
5050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5051 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5052 VOS_ASSERT(0);
5053 vos_mem_free(wdiRemoveBssKeyParam);
5054 return VOS_STATUS_E_NOMEM;
5055 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5056 /* copy Remove BSS key params to WDI structure*/
5057 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5058 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5059 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5060 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5061 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5062 /* Store remove key pointer, as this will be used for response */
5063 /* store Params pass it to WDI */
5064 pWdaParams->pWdaContext = pWDA;
5065 pWdaParams->wdaMsgParam = removeBssKeyParams;
5066 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5067 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5068 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5069 if(IS_WDI_STATUS_FAILURE(status))
5070 {
5071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5072 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5073 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5074 vos_mem_free(pWdaParams) ;
5075 removeBssKeyParams->status = eSIR_FAILURE ;
5076 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5077 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5078 return CONVERT_WDI2VOS_STATUS(status) ;
5079}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5080/*
5081 * FUNCTION: WDA_SetBssKeyReqCallback
5082 * send SET BSS key RSP back to PE
5083 */
5084void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5085{
5086 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5087 tWDA_CbContext *pWDA;
5088 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5090 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5091 if(NULL == pWdaParams)
5092 {
5093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5094 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5095 VOS_ASSERT(0) ;
5096 return ;
5097 }
5098 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5099 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5100 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5101 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5102 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5103 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5104 return ;
5105}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5106/*
5107 * FUNCTION: WDA_ProcessSetStaKeyReq
5108 * Request to WDI for programming the STA key( key for Unicast frames
5109 * Encryption)
5110 */
5111VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5112 tSetStaKeyParams *setStaKeyParams )
5113{
5114 WDI_Status status = WDI_STATUS_SUCCESS ;
5115 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5116 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5117 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5118 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5119 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5121 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5122 if(NULL == wdiSetStaKeyParam)
5123 {
5124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5125 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5126 VOS_ASSERT(0);
5127 return VOS_STATUS_E_NOMEM;
5128 }
5129 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5130 if(NULL == pWdaParams)
5131 {
5132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5133 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5134 VOS_ASSERT(0);
5135 vos_mem_free(wdiSetStaKeyParam);
5136 return VOS_STATUS_E_NOMEM;
5137 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5138 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5139 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5140 /* copy set STA key params to WDI structure */
5141 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5142 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5143 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5144 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5145 if(setStaKeyParams->encType != eSIR_ED_NONE)
5146 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5147 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5149 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5150 {
5151 WDA_GetWepKeysFromCfg( pWDA,
5152 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5153 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5154 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5155 }
5156 else
5157 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5158 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5159 keyIndex++)
5160 {
5161 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5162 setStaKeyParams->key[keyIndex].keyId;
5163 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5164 setStaKeyParams->key[keyIndex].unicast;
5165 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5166 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5167 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5168 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5169 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5170 setStaKeyParams->key[keyIndex].paeRole;
5171 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5172 setStaKeyParams->key[keyIndex].keyLength;
5173 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5174 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5175 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5176 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5177 {
5178 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5179 }
5180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5181 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5182 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5183 }
5184 }
5185 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5186 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5187 /* Store set key pointer, as this will be used for response */
5188 /* store Params pass it to WDI */
5189 pWdaParams->pWdaContext = pWDA;
5190 pWdaParams->wdaMsgParam = setStaKeyParams;
5191 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5192 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5193 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5194 if(IS_WDI_STATUS_FAILURE(status))
5195 {
5196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5197 "Failure in set STA Key Req WDI API, free all the memory " );
5198 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5199 vos_mem_free(pWdaParams) ;
5200 setStaKeyParams->status = eSIR_FAILURE ;
5201 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5202 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5203 return CONVERT_WDI2VOS_STATUS(status) ;
5204}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5205/*
5206 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5207 * send SET Bcast STA key RSP back to PE
5208 */
5209void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5210{
5211 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5212 tWDA_CbContext *pWDA;
5213 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5215 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5216 if(NULL == pWdaParams)
5217 {
5218 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5219 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5220 VOS_ASSERT(0) ;
5221 return ;
5222 }
5223 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5224 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5225 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5226 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5227 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5228 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5229 return ;
5230}
5231
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5232/*
5233 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5234 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5235 * Encryption)
5236 */
5237VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5238 tSetStaKeyParams *setStaKeyParams )
5239{
5240 WDI_Status status = WDI_STATUS_SUCCESS ;
5241 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5242 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5243 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5244 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5245 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5247 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5248 if(NULL == wdiSetStaKeyParam)
5249 {
5250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5251 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5252 VOS_ASSERT(0);
5253 return VOS_STATUS_E_NOMEM;
5254 }
5255 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5256 if(NULL == pWdaParams)
5257 {
5258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5259 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5260 VOS_ASSERT(0);
5261 vos_mem_free(wdiSetStaKeyParam);
5262 return VOS_STATUS_E_NOMEM;
5263 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5264 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5265 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5266 /* copy set STA key params to WDI structure */
5267 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5268 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5269 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5270 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5271 if(setStaKeyParams->encType != eSIR_ED_NONE)
5272 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5274 keyIndex++)
5275 {
5276 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5277 setStaKeyParams->key[keyIndex].keyId;
5278 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5279 setStaKeyParams->key[keyIndex].unicast;
5280 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5281 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5282 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5283 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5284 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5285 setStaKeyParams->key[keyIndex].paeRole;
5286 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5287 setStaKeyParams->key[keyIndex].keyLength;
5288 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5289 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5290 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5291 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5292 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5293 }
5294 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5295 /* Store set key pointer, as this will be used for response */
5296 /* store Params pass it to WDI */
5297 pWdaParams->pWdaContext = pWDA;
5298 pWdaParams->wdaMsgParam = setStaKeyParams;
5299 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5300 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5301 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5302 if(IS_WDI_STATUS_FAILURE(status))
5303 {
5304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5305 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5306 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5307 vos_mem_free(pWdaParams) ;
5308 setStaKeyParams->status = eSIR_FAILURE ;
5309 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5310 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5311 return CONVERT_WDI2VOS_STATUS(status) ;
5312}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5313/*
5314 * FUNCTION: WDA_RemoveStaKeyReqCallback
5315 * send SET BSS key RSP back to PE
5316 */
5317void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5318{
5319 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5320 tWDA_CbContext *pWDA;
5321 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5322 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5323 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5324 if(NULL == pWdaParams)
5325 {
5326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5327 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5328 VOS_ASSERT(0) ;
5329 return ;
5330 }
5331 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5332 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5333 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5334 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5335 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5336 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5337 return ;
5338}
5339
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5340/*
5341 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5342 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5343 */
5344VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5345 tRemoveStaKeyParams *removeStaKeyParams )
5346{
5347 WDI_Status status = WDI_STATUS_SUCCESS ;
5348 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5349 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5350 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5351 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5353 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5354 if(NULL == wdiRemoveStaKeyParam)
5355 {
5356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5357 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5358 VOS_ASSERT(0);
5359 return VOS_STATUS_E_NOMEM;
5360 }
5361 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5362 if(NULL == pWdaParams)
5363 {
5364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5365 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5366 VOS_ASSERT(0);
5367 vos_mem_free(wdiRemoveStaKeyParam);
5368 return VOS_STATUS_E_NOMEM;
5369 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5370 /* copy remove STA key params to WDI structure*/
5371 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5372 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5373 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5374 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5375 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5376 /* Store remove key pointer, as this will be used for response */
5377 /* store Params pass it to WDI */
5378 pWdaParams->pWdaContext = pWDA;
5379 pWdaParams->wdaMsgParam = removeStaKeyParams;
5380 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5381 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5382 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5383 if(IS_WDI_STATUS_FAILURE(status))
5384 {
5385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5386 "Failure in remove STA Key Req WDI API, free all the memory " );
5387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5388 vos_mem_free(pWdaParams) ;
5389 removeStaKeyParams->status = eSIR_FAILURE ;
5390 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5392 return CONVERT_WDI2VOS_STATUS(status) ;
5393}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5394/*
5395 * FUNCTION: WDA_IsHandleSetLinkStateReq
5396 * Update the WDA state and return the status to handle this message or not
5397 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5398WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5399 tWDA_CbContext *pWDA,
5400 tLinkStateParams *linkStateParams)
5401{
5402 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5403 switch(linkStateParams->state)
5404 {
5405 case eSIR_LINK_PREASSOC_STATE:
5406 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5407 /*
5408 * set the WDA state to PRE ASSOC
5409 * copy the BSSID into pWDA to use it in join request and return,
5410 * No need to handle these messages.
5411 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5412 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5413 {
5414 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5415 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5416 }
5417 else
5418 {
5419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5420 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5421 VOS_ASSERT(0);
5422 }
5423
5424 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5425 {
5426 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5427 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5428 }
5429 else
5430 {
5431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5432 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5433 VOS_ASSERT(0);
5434 }
5435
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5436 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5437 *channel and after ) so reset the WDA state to ready when the second
5438 * time UMAC issue the link state with PREASSOC
5439 */
5440 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5441 {
5442 /* RESET WDA state back to WDA_READY_STATE */
5443 pWDA->wdaState = WDA_READY_STATE;
5444 }
5445 else
5446 {
5447 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5448 }
5449 //populate linkState info in WDACbCtxt
5450 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5451 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5452 default:
5453 if(pWDA->wdaState != WDA_READY_STATE)
5454 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5455 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5456 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5457 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5458 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5459 *the ASSERT in WDA_Stop during module unload.*/
5460 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5461 {
5462 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5463 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5464 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5465 else
5466 {
5467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5468 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5469 status = WDA_IGNORE_SET_LINK_STATE;
5470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5471 }
5472 break;
5473 }
5474
5475 return status;
5476}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5477/*
5478 * FUNCTION: WDA_SetLinkStateCallback
5479 * call back function for set link state from WDI
5480 */
5481void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5482{
5483 tWDA_CbContext *pWDA;
5484 tLinkStateParams *linkStateParams;
5485 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5487 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5488 if(NULL == pWdaParams)
5489 {
5490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5491 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5492 VOS_ASSERT(0) ;
5493 return ;
5494 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5495 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5496 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5497 /*
5498 * In STA mode start the BA activity check timer after association
5499 * and in AP mode start BA activity check timer after BSS start */
5500 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5501 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5502 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5503 ((status == WDI_STATUS_SUCCESS) &&
5504 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5505 {
5506 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5508 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5509 /*
5510 * No respone required for WDA_SET_LINK_STATE so free the request
5511 * param here
5512 */
5513 if( pWdaParams != NULL )
5514 {
5515 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5516 {
5517 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5518 }
5519 vos_mem_free(pWdaParams);
5520 }
5521 return ;
5522}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5523/*
5524 * FUNCTION: WDA_ProcessSetLinkState
5525 * Request to WDI to set the link status.
5526 */
5527VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5528 tLinkStateParams *linkStateParams)
5529{
5530 WDI_Status status = WDI_STATUS_SUCCESS ;
5531 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5532 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5533 sizeof(WDI_SetLinkReqParamsType)) ;
5534 tWDA_ReqParams *pWdaParams ;
5535 tpAniSirGlobal pMac;
5536 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5537
5538 if(NULL == pMac)
5539 {
5540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5541 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5542 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5543 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5544 return VOS_STATUS_E_FAILURE;
5545 }
5546
5547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5548 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5549 if(NULL == wdiSetLinkStateParam)
5550 {
5551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5552 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5553 VOS_ASSERT(0);
5554 return VOS_STATUS_E_NOMEM;
5555 }
5556 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5557 if(NULL == pWdaParams)
5558 {
5559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5560 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5561 VOS_ASSERT(0);
5562 vos_mem_free(wdiSetLinkStateParam);
5563 return VOS_STATUS_E_NOMEM;
5564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5565 if(WDA_IGNORE_SET_LINK_STATE ==
5566 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5567 {
5568 status = WDI_STATUS_E_FAILURE;
5569 }
5570 else
5571 {
5572 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5573 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5574 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5575 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5576 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5577 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5578 pWdaParams->pWdaContext = pWDA;
5579 /* Store remove key pointer, as this will be used for response */
5580 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5581 /* store Params pass it to WDI */
5582 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5583 /* Stop Timer only other than GO role and concurrent session */
5584 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5585 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5586 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5587 {
5588 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5589 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5590 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5591 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5592 if(IS_WDI_STATUS_FAILURE(status))
5593 {
5594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5595 "Failure in set link state Req WDI API, free all the memory " );
5596 }
5597 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5598 if(IS_WDI_STATUS_FAILURE(status))
5599 {
5600 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5601 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5602 vos_mem_free(pWdaParams);
5603 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5604 return CONVERT_WDI2VOS_STATUS(status) ;
5605}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5606/*
5607 * FUNCTION: WDA_GetStatsReqParamsCallback
5608 * send the response to PE with Stats received from WDI
5609 */
5610void WDA_GetStatsReqParamsCallback(
5611 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5612 void* pUserData)
5613{
5614 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5615 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5616
5617 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5618 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5619 pGetPEStatsRspParams =
5620 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5621 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5622
5623 if(NULL == pGetPEStatsRspParams)
5624 {
5625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5626 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5627 VOS_ASSERT(0);
5628 return;
5629 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5630 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5631 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5632 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5633 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5634
5635 //Fill the Session Id Properly in PE
5636 pGetPEStatsRspParams->sessionId = 0;
5637 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5638 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5639 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5640 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5641 vos_mem_copy( pGetPEStatsRspParams + 1,
5642 wdiGetStatsRsp + 1,
5643 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5644 /* send response to UMAC*/
5645 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5646
5647 return;
5648}
5649
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5650/*
5651 * FUNCTION: WDA_ProcessGetStatsReq
5652 * Request to WDI to get the statistics
5653 */
5654VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5655 tAniGetPEStatsReq *pGetStatsParams)
5656{
5657 WDI_Status status = WDI_STATUS_SUCCESS ;
5658 WDI_GetStatsReqParamsType wdiGetStatsParam;
5659 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5661 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5662 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5663 pGetStatsParams->staId;
5664 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5665 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5666 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5667 status = WDI_GetStatsReq(&wdiGetStatsParam,
5668 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5669 if(IS_WDI_STATUS_FAILURE(status))
5670 {
5671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5672 "Failure in Get Stats Req WDI API, free all the memory " );
5673 pGetPEStatsRspParams =
5674 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5675 if(NULL == pGetPEStatsRspParams)
5676 {
5677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5678 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5679 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5680 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5681 return VOS_STATUS_E_NOMEM;
5682 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5683 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5684 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5685 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5686 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5687 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5688 (void *)pGetPEStatsRspParams, 0) ;
5689 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5690 /* Free the request message */
5691 vos_mem_free(pGetStatsParams);
5692 return CONVERT_WDI2VOS_STATUS(status);
5693}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5694
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5695#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5696/*
5697 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5698 * send the response to PE with roam Rssi received from WDI
5699 */
5700void WDA_GetRoamRssiReqParamsCallback(
5701 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5702 void* pUserData)
5703{
5704 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5705 tWDA_CbContext *pWDA = NULL;
5706 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5707 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5709 "<------ %s " ,__func__);
5710 if(NULL == pWdaParams)
5711 {
5712 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5713 "%s: pWdaParams received NULL", __func__);
5714 VOS_ASSERT(0) ;
5715 return ;
5716 }
5717 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5718 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5719
5720 if(NULL == pGetRoamRssiReqParams)
5721 {
5722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5723 "%s: pGetRoamRssiReqParams received NULL", __func__);
5724 VOS_ASSERT(0);
5725 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5726 vos_mem_free(pWdaParams);
5727 return ;
5728 }
5729 pGetRoamRssiRspParams =
5730 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5731
5732 if(NULL == pGetRoamRssiRspParams)
5733 {
5734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5735 "%s: VOS MEM Alloc Failure", __func__);
5736 VOS_ASSERT(0);
5737 return;
5738 }
5739 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5740 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5741 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5742 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5743 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5744
5745 /* Assign get roam rssi req (backup) in to the response */
5746 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5747
5748 /* free WDI command buffer */
5749 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5750 vos_mem_free(pWdaParams) ;
5751
5752 /* send response to UMAC*/
5753 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5754
5755 return;
5756}
5757
5758
5759
5760/*
5761 * FUNCTION: WDA_ProcessGetRoamRssiReq
5762 * Request to WDI to get the statistics
5763 */
5764VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5765 tAniGetRssiReq *pGetRoamRssiParams)
5766{
5767 WDI_Status status = WDI_STATUS_SUCCESS ;
5768 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5769 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5770 tWDA_ReqParams *pWdaParams = NULL;
5771
5772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5773 "------> %s " ,__func__);
5774 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5775 pGetRoamRssiParams->staId;
5776 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5777
5778 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5779 if(NULL == pWdaParams)
5780 {
5781 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5782 "%s: VOS MEM Alloc Failure", __func__);
5783 VOS_ASSERT(0);
5784 return VOS_STATUS_E_NOMEM;
5785 }
5786
5787 /* Store Init Req pointer, as this will be used for response */
5788 pWdaParams->pWdaContext = pWDA;
5789
5790 /* Take Get roam Rssi req backup as it stores the callback to be called after
5791 receiving the response */
5792 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5793 pWdaParams->wdaWdiApiMsgParam = NULL;
5794
5795 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5796 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5797 if(IS_WDI_STATUS_FAILURE(status))
5798 {
5799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5800 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5801 pGetRoamRssiRspParams =
5802 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5803 if(NULL == pGetRoamRssiRspParams)
5804 {
5805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5806 "%s: VOS MEM Alloc Failure", __func__);
5807 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5808 vos_mem_free(pGetRoamRssiParams);
5809 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5810 return VOS_STATUS_E_NOMEM;
5811 }
5812 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5813 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5814 pGetRoamRssiRspParams->rssi = 0;
5815 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5816 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5817 (void *)pGetRoamRssiRspParams, 0) ;
5818 }
5819 return CONVERT_WDI2VOS_STATUS(status);
5820}
5821#endif
5822
5823
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5824/*
5825 * FUNCTION: WDA_UpdateEDCAParamCallback
5826 * call back function for Update EDCA params from WDI
5827 */
5828void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5829{
5830 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5831 tEdcaParams *pEdcaParams;
5832
5833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5834 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5835 if(NULL == pWdaParams)
5836 {
5837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5838 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5839 VOS_ASSERT(0) ;
5840 return ;
5841 }
5842 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5844 vos_mem_free(pWdaParams);
5845 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5846 return ;
5847}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5848/*
5849 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5850 * Request to WDI to Update the EDCA params.
5851 */
5852VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5853 tEdcaParams *pEdcaParams)
5854{
5855 WDI_Status status = WDI_STATUS_SUCCESS ;
5856 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5857 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5858 sizeof(WDI_UpdateEDCAParamsType)) ;
5859 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5861 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5862 if(NULL == wdiEdcaParam)
5863 {
5864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5865 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5866 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5867 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5868 return VOS_STATUS_E_NOMEM;
5869 }
5870 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5871 if(NULL == pWdaParams)
5872 {
5873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5874 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5875 VOS_ASSERT(0);
5876 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5877 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5878 return VOS_STATUS_E_NOMEM;
5879 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5880 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5881 /*
5882 Since firmware is not using highperformance flag, we have removed
5883 this flag from wdiEDCAInfo structure to match sizeof the structure
5884 between host and firmware.In future if we are planning to use
5885 highperformance flag then Please define this flag in wdiEDCAInfo
5886 structure, update it here and send it to firmware. i.e.
5887 Following is the original line which we removed as part of the fix
5888 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5889 pEdcaParams->highPerformance;
5890 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5891 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5892 &pEdcaParams->acbe);
5893 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5894 &pEdcaParams->acbk);
5895 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5896 &pEdcaParams->acvi);
5897 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5898 &pEdcaParams->acvo);
5899 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5900 pWdaParams->pWdaContext = pWDA;
5901 /* Store remove key pointer, as this will be used for response */
5902 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5903 /* store Params pass it to WDI */
5904 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5905 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5906 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5907 if(IS_WDI_STATUS_FAILURE(status))
5908 {
5909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5910 "Failure in Update EDCA Params WDI API, free all the memory " );
5911 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5912 vos_mem_free(pWdaParams);
5913 vos_mem_free(pEdcaParams);
5914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5915 return CONVERT_WDI2VOS_STATUS(status) ;
5916}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5917/*
5918 * FUNCTION: WDA_AddBAReqCallback
5919 * send ADD BA RSP back to PE
5920 */
5921void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5922 void* pUserData)
5923{
5924 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5925 tWDA_CbContext *pWDA;
5926 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5927 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5928 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5929 if(NULL == pWdaParams)
5930 {
5931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5932 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5933 VOS_ASSERT(0) ;
5934 return ;
5935 }
5936 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5937 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5938 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5939 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5940 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5941 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5942 return ;
5943}
5944
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5945/*
5946 * FUNCTION: WDA_ProcessAddBAReq
5947 * Request to WDI to Update the ADDBA REQ params.
5948 */
5949VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5950 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5951{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5952 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5953 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5954 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5955 sizeof(WDI_AddBAReqParamsType)) ;
5956 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5958 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5959 if(NULL == wdiAddBAReqParam)
5960 {
5961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5962 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5963 VOS_ASSERT(0);
5964 return VOS_STATUS_E_NOMEM;
5965 }
5966 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5967 if(NULL == pWdaParams)
5968 {
5969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5970 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5971 VOS_ASSERT(0);
5972 vos_mem_free(wdiAddBAReqParam);
5973 return VOS_STATUS_E_NOMEM;
5974 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5975 do
5976 {
5977 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5978 wdiAddBaInfo->ucSTAIdx = staIdx ;
5979 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5980 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5981 } while(0) ;
5982 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5983 pWdaParams->pWdaContext = pWDA;
5984 /* store Params pass it to WDI */
5985 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5986 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5987 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5988 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5989
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5990 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5991 {
5992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5993 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5994 status = CONVERT_WDI2VOS_STATUS(wstatus);
5995 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5996 vos_mem_free(pWdaParams);
5997 pAddBAReqParams->status = eSIR_FAILURE;
5998 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5999 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6000 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6001}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6002/*
6003 * FUNCTION: WDA_AddBASessionReqCallback
6004 * send ADD BA SESSION RSP back to PE/(or TL)
6005 */
6006void WDA_AddBASessionReqCallback(
6007 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
6008{
6009 VOS_STATUS status = VOS_STATUS_SUCCESS ;
6010 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6011 tWDA_CbContext *pWDA;
6012 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6013 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6014 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6015 if(NULL == pWdaParams)
6016 {
6017 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6018 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6019 VOS_ASSERT(0) ;
6020 return ;
6021 }
6022 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6023 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6024 if( NULL == pAddBAReqParams )
6025 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6027 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6028 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6029 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6030 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6031 return ;
6032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6033 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6034 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6035 /*
6036 * if WDA in update TL state, update TL with BA session parama and send
6037 * another request to HAL(/WDI) (ADD_BA_REQ)
6038 */
6039
6040 if((VOS_STATUS_SUCCESS ==
6041 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
6042 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
6043 {
6044 /* Update TL with BA info received from HAL/WDI */
6045 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
6046 wdiAddBaSession->usBaSessionID,
6047 wdiAddBaSession->ucSTAIdx,
6048 wdiAddBaSession->ucBaTID,
6049 wdiAddBaSession->ucBaBufferSize,
6050 wdiAddBaSession->ucWinSize,
6051 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6052 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
6053 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
6054 }
6055 else
6056 {
6057 pAddBAReqParams->status =
6058 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6059
6060 /* Setting Flag to indicate that Set BA is success */
6061 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6062 {
6063 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6064 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6065 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6066 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6067 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6068 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6069 /*Reset the WDA state to READY */
6070 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6071 return ;
6072}
6073
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6074/*
6075 * FUNCTION: WDA_ProcessAddBASessionReq
6076 * Request to WDI to Update the ADDBA REQ params.
6077 */
6078VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6079 tAddBAParams *pAddBAReqParams)
6080{
6081 WDI_Status status = WDI_STATUS_SUCCESS ;
6082 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6083 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6084 sizeof(WDI_AddBASessionReqParamsType)) ;
6085 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6086 WLANTL_STAStateType tlSTAState = 0;
6087
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6089 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6090 if(NULL == wdiAddBASessionReqParam)
6091 {
6092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6093 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6094 VOS_ASSERT(0);
6095 return VOS_STATUS_E_NOMEM;
6096 }
6097 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6098 if(NULL == pWdaParams)
6099 {
6100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6101 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6102 VOS_ASSERT(0);
6103 vos_mem_free(wdiAddBASessionReqParam);
6104 return VOS_STATUS_E_NOMEM;
6105 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6106 /*
6107 * Populate ADD BA parameters and pass these paarmeters to WDI.
6108 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6109 * the state to track if these is BA recipient case or BA initiator
6110 * case.
6111 */
6112 do
6113 {
6114 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6115 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6116 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6117 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6118 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6119 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6120 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6121 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6122 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6123 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6124 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6125 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6126 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6127 /* check the BA direction and update state accordingly */
6128 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
6129 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
6130 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
6131
6132 }while(0) ;
6133 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6134 pWdaParams->pWdaContext = pWDA;
6135 /* Store ADD BA pointer, as this will be used for response */
6136 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6137 /* store Params pass it to WDI */
6138 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6139
6140 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6141 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6142 */
6143 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6144 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6145 {
6146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6147 "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]6148 status = WDI_STATUS_E_NOT_ALLOWED;
6149 pAddBAReqParams->status =
6150 CONVERT_WDI2SIR_STATUS(status) ;
6151 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6152 /*Reset the WDA state to READY */
6153 pWDA->wdaState = WDA_READY_STATE;
6154 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6155 vos_mem_free(pWdaParams);
6156
6157 return CONVERT_WDI2VOS_STATUS(status) ;
6158 }
6159
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6160 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6161 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6162 if(IS_WDI_STATUS_FAILURE(status))
6163 {
6164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6165 "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]6166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6167 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6168 pAddBAReqParams->status =
6169 CONVERT_WDI2SIR_STATUS(status) ;
6170 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6171 /*Reset the WDA state to READY */
6172 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6173 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6174 vos_mem_free(pWdaParams);
6175 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6176 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6177}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6178/*
6179 * FUNCTION: WDA_DelBANotifyTL
6180 * send DEL BA IND to TL
6181 */
6182void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6183 tDelBAParams *pDelBAReqParams)
6184{
6185 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6186 //tSirMsgQ msg;
6187 vos_msg_t vosMsg;
6188 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6189 if(NULL == pDelBAInd)
6190 {
6191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6192 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6193 VOS_ASSERT(0) ;
6194 return;
6195 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6196 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6197 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6198 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6199 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6200
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6201
6202 vosMsg.type = WDA_DELETEBA_IND;
6203 vosMsg.bodyptr = pDelBAInd;
6204 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6205 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6206 {
6207 vosStatus = VOS_STATUS_E_BADMSG;
6208 }
6209}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6210/*
6211 * FUNCTION: WDA_DelBAReqCallback
6212 * send DEL BA RSP back to PE
6213 */
6214void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6215{
6216 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6217 tWDA_CbContext *pWDA;
6218 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6220 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6221 if(NULL == pWdaParams)
6222 {
6223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6224 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6225 VOS_ASSERT(0) ;
6226 return ;
6227 }
6228 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6229 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6230 /* Notify TL about DEL BA in case of recipinet */
6231 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6232 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6233 {
6234 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6236 /*
6237 * No respone required for WDA_DELBA_IND so just free the request
6238 * param here
6239 */
6240 vos_mem_free(pDelBAReqParams);
6241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6242 vos_mem_free(pWdaParams);
6243 return ;
6244}
6245
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6246/*
6247 * FUNCTION: WDA_ProcessDelBAReq
6248 * Request to WDI to Update the DELBA REQ params.
6249 */
6250VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6251 tDelBAParams *pDelBAReqParams)
6252{
6253 WDI_Status status = WDI_STATUS_SUCCESS ;
6254 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6255 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6256 sizeof(WDI_DelBAReqParamsType)) ;
6257 tWDA_ReqParams *pWdaParams ;
6258 tANI_U16 staIdx = 0;
6259 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6261 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6262 if(NULL == wdiDelBAReqParam)
6263 {
6264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6265 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6266 VOS_ASSERT(0);
6267 return VOS_STATUS_E_NOMEM;
6268 }
6269 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6270 if(NULL == pWdaParams)
6271 {
6272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6273 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6274 VOS_ASSERT(0);
6275 vos_mem_free(wdiDelBAReqParam);
6276 return VOS_STATUS_E_NOMEM;
6277 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6278 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6279 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6280 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6281 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6282 pWdaParams->pWdaContext = pWDA;
6283 /* Store DEL BA pointer, as this will be used for response */
6284 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6285 /* store Params pass it to WDI */
6286 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6287 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6288 * maintained in WDA, so that WDA can retry for another BA session
6289 */
6290 staIdx = pDelBAReqParams->staIdx;
6291 tid = pDelBAReqParams->baTID;
6292 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6293 status = WDI_DelBAReq(wdiDelBAReqParam,
6294 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6295 if(IS_WDI_STATUS_FAILURE(status))
6296 {
6297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6298 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6299 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6300 vos_mem_free(pWdaParams->wdaMsgParam);
6301 vos_mem_free(pWdaParams);
6302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6303 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6304}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6305
6306/*
6307 * FUNCTION: WDA_UpdateChReqCallback
6308 *
6309 */
6310void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6311{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6312 tWDA_ReqParams *pWdaParams;
6313 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6314 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6315 WDI_UpdateChannelReqinfoType *pChanInfoType;
6316 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6317
6318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6319 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6320 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6321 {
6322 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6323 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6324 VOS_ASSERT(0);
6325 return;
6326 }
6327
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6328 pWdaParams = (tWDA_ReqParams *)pUserData;
6329 pwdiUpdateChReqParam =
6330 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6331 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6332 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6333 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6334 /*
6335 * currently there is no response message is expected between PE and
6336 * WDA, Failure return from WDI is a ASSERT condition
6337 */
6338 vos_mem_free(pChanInfoType);
6339 vos_mem_free(pChanList);
6340 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6341 vos_mem_free(pWdaParams);
6342
6343 return;
6344}
6345
6346/*
6347 * FUNCTION: WDA_ProcessUpdateChannelList
6348 * Request to WDI to Update the ChannelList params.
6349 */
6350VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6351 tSirUpdateChanList *pChanList)
6352{
6353 WDI_Status status = WDI_STATUS_SUCCESS;
6354 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6355 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6356 WDI_UpdateChannelReqinfoType *pChanInfoType;
6357 tWDA_ReqParams *pWdaParams;
6358 wpt_uint8 i;
6359
6360 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6361 "------> %s " ,__func__);
6362 if(NULL == pChanList)
6363 {
6364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6365 "%s: NULL pChanList", __func__);
6366 VOS_ASSERT(0);
6367 return VOS_STATUS_E_INVAL;
6368 }
6369
6370 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6371 {
6372 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6373 "Update channel list capability Not Supported");
6374 vos_mem_free(pChanList);
6375 return VOS_STATUS_E_INVAL;
6376 }
6377
6378 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6379 sizeof(WDI_UpdateChReqParamsType));
6380 if(NULL == pwdiUpdateChReqParam)
6381 {
6382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6383 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6384 __func__);
6385 VOS_ASSERT(0);
6386 vos_mem_free(pChanList);
6387 return VOS_STATUS_E_NOMEM;
6388 }
6389 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6390 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6391 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6392 pChanList->numChan);
6393 if(NULL == pChanInfoType)
6394 {
6395 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6396 "%s: VOS MEM Alloc Failure", __func__);
6397 VOS_ASSERT(0);
6398 vos_mem_free(pChanList);
6399 vos_mem_free(pwdiUpdateChReqParam);
6400 return VOS_STATUS_E_NOMEM;
6401 }
6402 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6403 * pChanList->numChan);
6404 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6405
6406 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6407 if(NULL == pWdaParams)
6408 {
6409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6410 "%s: VOS MEM Alloc Failure", __func__);
6411 VOS_ASSERT(0);
6412 vos_mem_free(pChanList);
6413 vos_mem_free(pChanInfoType);
6414 vos_mem_free(pwdiUpdateChReqParam);
6415 return VOS_STATUS_E_NOMEM;
6416 }
6417 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6418
6419 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6420 {
6421 pChanInfoType->mhz =
6422 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6423
6424 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6425 pChanInfoType->band_center_freq2 = 0;
6426
6427 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6428 "chan[%d] = %u", i, pChanInfoType->mhz);
6429 if (pChanList->chanParam[i].dfsSet)
6430 {
6431 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6433 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6434 pChanList->chanParam[i].dfsSet);
6435 }
6436
6437 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6438 {
6439 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6440 }
6441 else
6442 {
6443 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6444 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6445 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6446 }
6447
6448 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6449 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6450
6451 pChanInfoType++;
6452 }
6453
6454 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6455 pWdaParams->pWdaContext = pWDA;
6456 pWdaParams->wdaMsgParam = (void *)pChanList;
6457 /* store Params pass it to WDI */
6458 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6459 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6460 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6461 if(IS_WDI_STATUS_FAILURE(status))
6462 {
6463 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6464 "Failure in Update Channel REQ Params WDI API, free all the memory");
6465 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6466 vos_mem_free(pwdiUpdateChReqParam);
6467 vos_mem_free(pWdaParams->wdaMsgParam);
6468 vos_mem_free(pWdaParams);
6469 }
6470 return CONVERT_WDI2VOS_STATUS(status);
6471}
6472
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6473/*
6474 * FUNCTION: WDA_AddTSReqCallback
6475 * send ADD TS RSP back to PE
6476 */
6477void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6478{
6479 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6480 tWDA_CbContext *pWDA;
6481 tAddTsParams *pAddTsReqParams;
6482
6483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6484 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6485 if(NULL == pWdaParams)
6486 {
6487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6488 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6489 VOS_ASSERT(0) ;
6490 return ;
6491 }
6492 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6493 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6494 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6495 vos_mem_free(pWdaParams);
6496
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6497 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6498 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6499 return ;
6500}
6501
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6502/*
6503 * FUNCTION: WDA_ProcessAddTSReq
6504 * Request to WDI to Update the ADD TS REQ params.
6505 */
6506VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6507 tAddTsParams *pAddTsReqParams)
6508{
6509 WDI_Status status = WDI_STATUS_SUCCESS ;
6510 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6511 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6512 sizeof(WDI_AddTSReqParamsType)) ;
6513 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6515 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6516 if(NULL == wdiAddTSReqParam)
6517 {
6518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6519 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6520 VOS_ASSERT(0);
6521 return VOS_STATUS_E_NOMEM;
6522 }
6523 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6524 if(NULL == pWdaParams)
6525 {
6526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6527 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6528 VOS_ASSERT(0);
6529 vos_mem_free(wdiAddTSReqParam);
6530 return VOS_STATUS_E_NOMEM;
6531 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6532 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6533 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6534 //TS IE
6535 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6536 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6537 pAddTsReqParams->tspec.length;
6538
6539 //TS IE : TS INFO : TRAFFIC
6540 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6541 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6542 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6543 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6544 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6545 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6546 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6547 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6548 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6549 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6550 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6551 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6552 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6553 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6554 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6555 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6556
6557 //TS IE : TS INFO : SCHEDULE
6558 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6559 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6560 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6561 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6562 //TS IE
6563 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6564 pAddTsReqParams->tspec.nomMsduSz;
6565 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6566 pAddTsReqParams->tspec.maxMsduSz;
6567 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6568 pAddTsReqParams->tspec.minSvcInterval;
6569 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6570 pAddTsReqParams->tspec.maxSvcInterval;
6571 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6572 pAddTsReqParams->tspec.inactInterval;
6573 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6574 pAddTsReqParams->tspec.suspendInterval;
6575 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6576 pAddTsReqParams->tspec.svcStartTime;
6577 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6578 pAddTsReqParams->tspec.minDataRate;
6579 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6580 pAddTsReqParams->tspec.meanDataRate;
6581 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6582 pAddTsReqParams->tspec.peakDataRate;
6583 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6584 pAddTsReqParams->tspec.maxBurstSz;
6585 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6586 pAddTsReqParams->tspec.delayBound;
6587 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6588 pAddTsReqParams->tspec.minPhyRate;
6589 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6590 pAddTsReqParams->tspec.surplusBw;
6591 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6592 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6593 /* TODO: tAddTsParams doesn't have the following fields */
6594#if 0
6595 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6596 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6597 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6598 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6599#endif
6600 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6601
6602 pWdaParams->pWdaContext = pWDA;
6603 /* Store ADD TS pointer, as this will be used for response */
6604 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6605 /* store Params pass it to WDI */
6606 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6607 status = WDI_AddTSReq(wdiAddTSReqParam,
6608 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6609 if(IS_WDI_STATUS_FAILURE(status))
6610 {
6611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6612 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6613 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6614 vos_mem_free(pWdaParams);
6615 pAddTsReqParams->status = eSIR_FAILURE ;
6616 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6617 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6618 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6619}
6620
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6621/*
6622 * FUNCTION: WDA_DelTSReqCallback
6623 * send DEL TS RSP back to PE
6624 */
6625void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6626{
6627 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
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 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6631 vos_mem_free(pWdaParams->wdaMsgParam) ;
6632 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6633 /*
6634 * No respone required for WDA_DEL_TS_REQ so just free the request
6635 * param here
6636 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6637 return ;
6638}
6639
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6640/*
6641 * FUNCTION: WDA_ProcessDelTSReq
6642 * Request to WDI to Update the DELTS REQ params.
6643 */
6644VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6645 tDelTsParams *pDelTSReqParams)
6646{
6647 WDI_Status status = WDI_STATUS_SUCCESS ;
6648 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6649 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6650 sizeof(WDI_DelTSReqParamsType)) ;
6651 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6653 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6654 if(NULL == wdiDelTSReqParam)
6655 {
6656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6657 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6658 VOS_ASSERT(0);
6659 return VOS_STATUS_E_NOMEM;
6660 }
6661 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6662 if(NULL == pWdaParams)
6663 {
6664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6665 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6666 VOS_ASSERT(0);
6667 vos_mem_free(wdiDelTSReqParam);
6668 return VOS_STATUS_E_NOMEM;
6669 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6670 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6671 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6672 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6673 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6674 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6675 pWdaParams->pWdaContext = pWDA;
6676 /* Store DEL TS pointer, as this will be used for response */
6677 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6678 /* store Params pass it to WDI */
6679 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6680 status = WDI_DelTSReq(wdiDelTSReqParam,
6681 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6682 if(IS_WDI_STATUS_FAILURE(status))
6683 {
6684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6685 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6686 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6687 vos_mem_free(pWdaParams->wdaMsgParam);
6688 vos_mem_free(pWdaParams);
6689 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6690 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6691}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6692/*
6693 * FUNCTION: WDA_UpdateBeaconParamsCallback
6694 * Free the memory. No need to send any response to PE in this case
6695 */
6696void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6697{
6698 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6700 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6701 if(NULL == pWdaParams)
6702 {
6703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6704 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6705 VOS_ASSERT(0) ;
6706 return ;
6707 }
6708 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6709 vos_mem_free(pWdaParams->wdaMsgParam) ;
6710 vos_mem_free(pWdaParams);
6711 /*
6712 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6713 * param here
6714 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6715 return ;
6716}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6717/*
6718 * FUNCTION: WDA_ProcessUpdateBeaconParams
6719 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6720 */
6721VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6722 tUpdateBeaconParams *pUpdateBeaconParams)
6723{
6724 WDI_Status status = WDI_STATUS_SUCCESS ;
6725 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6726 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6727 sizeof(WDI_UpdateBeaconParamsType)) ;
6728 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6730 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6731 if(NULL == wdiUpdateBeaconParams)
6732 {
6733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6734 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6735 VOS_ASSERT(0);
6736 return VOS_STATUS_E_NOMEM;
6737 }
6738 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6739 if(NULL == pWdaParams)
6740 {
6741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6742 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6743 VOS_ASSERT(0);
6744 vos_mem_free(wdiUpdateBeaconParams);
6745 return VOS_STATUS_E_NOMEM;
6746 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6747 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6748 pUpdateBeaconParams->bssIdx;
6749 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6750 pUpdateBeaconParams->fShortPreamble;
6751 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6752 pUpdateBeaconParams->fShortSlotTime;
6753 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6754 pUpdateBeaconParams->beaconInterval;
6755 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6756 pUpdateBeaconParams->llaCoexist;
6757 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6758 pUpdateBeaconParams->llbCoexist;
6759 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6760 pUpdateBeaconParams->llgCoexist;
6761 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6762 pUpdateBeaconParams->ht20MhzCoexist;
6763 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6764 pUpdateBeaconParams->llnNonGFCoexist;
6765 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6766 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6767 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6768 pUpdateBeaconParams->fRIFSMode;
6769 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6770 pUpdateBeaconParams->paramChangeBitmap;
6771 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6772
6773 pWdaParams->pWdaContext = pWDA;
6774 /* Store UpdateBeacon Req pointer, as this will be used for response */
6775 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 /* store Params pass it to WDI */
6777 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6778 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6779 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6780 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6781 if(IS_WDI_STATUS_FAILURE(status))
6782 {
6783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6784 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6785 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6786 vos_mem_free(pWdaParams->wdaMsgParam);
6787 vos_mem_free(pWdaParams);
6788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6789 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6790}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6791#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6792/*
6793 * FUNCTION: WDA_TSMStatsReqCallback
6794 * send TSM Stats RSP back to PE
6795 */
6796void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6797{
6798 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6799 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6800 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6801 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6802
6803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6804 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6805 if(NULL == pWdaParams)
6806 {
6807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6808 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6809 VOS_ASSERT(0) ;
6810 return ;
6811 }
6812 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6813 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6814
6815 if(NULL == pGetTsmStatsReqParams)
6816 {
6817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6818 "%s: pGetTsmStatsReqParams received NULL", __func__);
6819 VOS_ASSERT(0);
6820 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6821 vos_mem_free(pWdaParams);
6822 return;
6823 }
6824
6825 pTsmRspParams =
6826 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6827 if( NULL == pTsmRspParams )
6828 {
6829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6830 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6831 VOS_ASSERT( 0 );
6832 return ;
6833 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6834 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6835 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6836 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6837
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6838 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6839 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6840 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6841 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6842 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6843 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6844 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6845 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6846 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6847 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6848
6849 /* Assign get tsm stats req req (backup) in to the response */
6850 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6851
6852 /* free WDI command buffer */
6853 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6854 vos_mem_free(pWdaParams);
6855
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6856 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6857 return ;
6858}
6859
6860
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6861/*
6862 * FUNCTION: WDA_ProcessTsmStatsReq
6863 * Request to WDI to get the TSM Stats params.
6864 */
6865VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6866 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6867{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6868 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6869 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6870 tWDA_ReqParams *pWdaParams = NULL;
6871 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6872
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6874 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6875 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6876 sizeof(WDI_TSMStatsReqParamsType));
6877 if(NULL == wdiTSMReqParam)
6878 {
6879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6880 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6881 VOS_ASSERT(0);
6882 return VOS_STATUS_E_NOMEM;
6883 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6885 if(NULL == pWdaParams)
6886 {
6887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6888 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6889 VOS_ASSERT(0);
6890 vos_mem_free(wdiTSMReqParam);
6891 return VOS_STATUS_E_NOMEM;
6892 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6893 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6894 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6895 pTsmStats->bssId,
6896 sizeof(wpt_macAddr));
6897 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6898
6899 pWdaParams->pWdaContext = pWDA;
6900 /* Store TSM Stats pointer, as this will be used for response */
6901 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6902 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6903 status = WDI_TSMStatsReq(wdiTSMReqParam,
6904 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6905 if(IS_WDI_STATUS_FAILURE(status))
6906 {
6907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6908 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6909 vos_mem_free(pWdaParams);
6910
6911 pGetTsmStatsRspParams =
6912 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6913 if(NULL == pGetTsmStatsRspParams)
6914 {
6915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6916 "%s: VOS MEM Alloc Failure", __func__);
6917 VOS_ASSERT(0);
6918 vos_mem_free(pTsmStats);
6919 return VOS_STATUS_E_NOMEM;
6920 }
6921 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6922 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6923 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6924
6925 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6927 return CONVERT_WDI2VOS_STATUS(status) ;
6928}
6929#endif
6930/*
6931 * FUNCTION: WDA_SendBeaconParamsCallback
6932 * No need to send any response to PE in this case
6933 */
6934void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6935{
6936
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6938 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6939 return ;
6940}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6941/*
6942 * FUNCTION: WDA_ProcessSendBeacon
6943 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6944 * start beacon trasmission
6945 */
6946VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6947 tSendbeaconParams *pSendbeaconParams)
6948{
6949 WDI_Status status = WDI_STATUS_SUCCESS ;
6950 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6952 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6953 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6954 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6955 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6956 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6957 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6958 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6959 /* p2pIeOffset should be atleast greater than timIeOffset */
6960 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6961 (pSendbeaconParams->p2pIeOffset <
6962 pSendbeaconParams->timIeOffset))
6963 {
6964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6965 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6966 VOS_ASSERT( 0 );
6967 return WDI_STATUS_E_FAILURE;
6968 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6969 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6970 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6971 /* Copy the beacon template to local buffer */
6972 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6973 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6974 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6975
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6976 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6977 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6978 if(IS_WDI_STATUS_FAILURE(status))
6979 {
6980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6981 "Failure in SEND BEACON REQ Params WDI API" );
6982 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6983 vos_mem_free(pSendbeaconParams);
6984 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6985}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6986/*
6987 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6988 * No need to send any response to PE in this case
6989 */
6990void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6991{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6993 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6994 return ;
6995}
6996
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6997/*
6998 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6999 * Request to WDI to send the probe response template to HAL to update the TPE memory and
7000 * send probe response
7001 */
7002VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
7003 tSendProbeRespParams *pSendProbeRspParams)
7004{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7005 WDI_Status status = WDI_STATUS_SUCCESS;
7006 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
7007 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7009 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7010
7011 if (!wdiSendProbeRspParam)
7012 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
7013
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7014 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7015 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7016 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7017 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7018 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7019 /* Copy the Probe Response template to local buffer */
7020 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7021 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7022 pSendProbeRspParams->pProbeRespTemplate,
7023 pSendProbeRspParams->probeRespTemplateLen);
7024 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7025 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7026 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
7027 WDI_PROBE_REQ_BITMAP_IE_LEN);
7028
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7029 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7030
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7031 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7032 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7033 if(IS_WDI_STATUS_FAILURE(status))
7034 {
7035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7036 "Failure in SEND Probe RSP Params WDI API" );
7037 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7038 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7039 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7040 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7041}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7042#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7043/*
7044 * FUNCTION: WDA_SetMaxTxPowerCallBack
7045 * send the response to PE with power value received from WDI
7046 */
7047void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7048 void* pUserData)
7049{
7050 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7051 tWDA_CbContext *pWDA = NULL;
7052 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
7053
7054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7055 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7056 if(NULL == pWdaParams)
7057 {
7058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7059 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7060 VOS_ASSERT(0) ;
7061 return ;
7062 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7063 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7064 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7065 if( NULL == pMaxTxPowerParams )
7066 {
7067 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7068 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7069 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7070 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7071 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7072 return ;
7073 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7074
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7075
7076 /*need to free memory for the pointers used in the
7077 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7078 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7079 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7080 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7081
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7082
7083 /* send response to UMAC*/
7084 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7085
7086 return;
7087}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7088/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7089 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7090 * Request to WDI to send set Max Tx Power Request
7091 */
7092 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7093 tMaxTxPowerParams *MaxTxPowerParams)
7094{
7095 WDI_Status status = WDI_STATUS_SUCCESS;
7096 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7097 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7098
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7100 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7101
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7102 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7103 sizeof(WDI_SetMaxTxPowerParamsType));
7104 if(NULL == wdiSetMaxTxPowerParams)
7105 {
7106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7107 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7108 VOS_ASSERT(0);
7109 return VOS_STATUS_E_NOMEM;
7110 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7111 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7112 if(NULL == pWdaParams)
7113 {
7114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7115 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7116 vos_mem_free(wdiSetMaxTxPowerParams);
7117 VOS_ASSERT(0);
7118 return VOS_STATUS_E_NOMEM;
7119 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7120 /* Copy.Max.Tx.Power Params to WDI structure */
7121 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7122 MaxTxPowerParams->bssId,
7123 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7124 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7125 MaxTxPowerParams->selfStaMacAddr,
7126 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7127 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7128 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7129 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7130 pWdaParams->pWdaContext = pWDA;
7131 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7132 /* store Params pass it to WDI */
7133 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7134 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7135 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7136 if(IS_WDI_STATUS_FAILURE(status))
7137 {
7138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7139 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7140 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7141 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7142 /* send response to UMAC*/
7143 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7144 }
7145 return CONVERT_WDI2VOS_STATUS(status);
7146
7147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7148#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7149
7150/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7151 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7152 * send the response to PE with power value received from WDI
7153 */
7154void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7155 *pwdiSetMaxTxPowerPerBandRsp,
7156 void* pUserData)
7157{
7158 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7159 tWDA_CbContext *pWDA = NULL;
7160 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7161
7162 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7163 "<------ %s ", __func__);
7164 if (NULL == pWdaParams)
7165 {
7166 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7167 "%s: pWdaParams received NULL", __func__);
7168 VOS_ASSERT(0);
7169 return ;
7170 }
7171 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7172 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7173 if ( NULL == pMxTxPwrPerBandParams )
7174 {
7175 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7176 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7177 VOS_ASSERT(0);
7178 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7179 vos_mem_free(pWdaParams);
7180 return;
7181 }
7182
7183 /*need to free memory for the pointers used in the
7184 WDA Process.Set Max Tx Power Req function*/
7185 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7186 vos_mem_free(pWdaParams);
7187 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7188
7189 /* send response to UMAC*/
7190 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7191 pMxTxPwrPerBandParams, 0);
7192
7193 return;
7194}
7195
7196/*
7197 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7198 * Request to WDI to send set Max Tx Power Per band Request
7199 */
7200 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7201 tMaxTxPowerPerBandParams
7202 *MaxTxPowerPerBandParams)
7203{
7204 WDI_Status status = WDI_STATUS_SUCCESS;
7205 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7206 tWDA_ReqParams *pWdaParams = NULL;
7207
7208 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7209 "------> %s ", __func__);
7210
7211 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7212 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7213
7214 if (NULL == wdiSetMxTxPwrPerBandParams)
7215 {
7216 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7217 "%s: VOS MEM Alloc Failure", __func__);
7218 VOS_ASSERT(0);
7219 return VOS_STATUS_E_NOMEM;
7220 }
7221 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7222 if (NULL == pWdaParams)
7223 {
7224 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7225 "%s: VOS MEM Alloc Failure", __func__);
7226 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7227 VOS_ASSERT(0);
7228 return VOS_STATUS_E_NOMEM;
7229 }
7230 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7231 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7232 MaxTxPowerPerBandParams->bandInfo;
7233 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7234 MaxTxPowerPerBandParams->power;
7235 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7236 pWdaParams->pWdaContext = pWDA;
7237 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7238 /* store Params pass it to WDI */
7239 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7240 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7241 WDA_SetMaxTxPowerPerBandCallBack,
7242 pWdaParams);
7243 if (IS_WDI_STATUS_FAILURE(status))
7244 {
7245 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7246 "Failure in SET MAX TX Power REQ Params WDI API,"
7247 " free all the memory");
7248 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7249 vos_mem_free(pWdaParams);
7250 /* send response to UMAC*/
7251 WDA_SendMsg(pWDA,
7252 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7253 MaxTxPowerPerBandParams, 0);
7254 }
7255 return CONVERT_WDI2VOS_STATUS(status);
7256}
7257
7258/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7259 * FUNCTION: WDA_SetTxPowerCallBack
7260 * send the response to PE with power value received from WDI
7261 */
7262void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7263 void* pUserData)
7264{
7265 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7266 tWDA_CbContext *pWDA = NULL;
7267 tSirSetTxPowerReq *pTxPowerParams = NULL;
7268
7269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7270 "<------ %s ", __func__);
7271 if(NULL == pWdaParams)
7272 {
7273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7274 "%s: pWdaParams received NULL", __func__);
7275 VOS_ASSERT(0) ;
7276 return ;
7277 }
7278 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7279 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7280 if(NULL == pTxPowerParams)
7281 {
7282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7283 "%s: pTxPowerParams received NULL " ,__func__);
7284 VOS_ASSERT(0);
7285 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7286 vos_mem_free(pWdaParams);
7287 return ;
7288 }
7289
7290 /*need to free memory for the pointers used in the
7291 WDA Process.Set Max Tx Power Req function*/
7292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7293 vos_mem_free(pWdaParams);
7294
7295 /* send response to UMAC*/
7296 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7297 return;
7298}
7299
7300/*
7301 * FUNCTION: WDA_ProcessSetTxPowerReq
7302 * Request to WDI to send set Tx Power Request
7303 */
7304 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7305 tSirSetTxPowerReq *txPowerParams)
7306{
7307 WDI_Status status = WDI_STATUS_SUCCESS;
7308 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7309 tWDA_ReqParams *pWdaParams = NULL;
7310
7311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7312 "------> %s ", __func__);
7313
7314 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7315 sizeof(WDI_SetTxPowerParamsType));
7316 if(NULL == wdiSetTxPowerParams)
7317 {
7318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7319 "%s: VOS MEM Alloc Failure", __func__);
7320 VOS_ASSERT(0);
7321 return VOS_STATUS_E_NOMEM;
7322 }
7323 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7324 if(NULL == pWdaParams)
7325 {
7326 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7327 "%s: VOS MEM Alloc Failure", __func__);
7328 vos_mem_free(wdiSetTxPowerParams);
7329 VOS_ASSERT(0);
7330 return VOS_STATUS_E_NOMEM;
7331 }
7332 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7333 txPowerParams->bssIdx;
7334 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7335 txPowerParams->mwPower;
7336 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7337 pWdaParams->pWdaContext = pWDA;
7338 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7339 /* store Params pass it to WDI */
7340 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7341 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7342 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7343 if(IS_WDI_STATUS_FAILURE(status))
7344 {
7345 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7346 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7347 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7348 vos_mem_free(pWdaParams);
7349 /* send response to UMAC*/
7350 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7351 }
7352 return CONVERT_WDI2VOS_STATUS(status);
7353}
7354
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7355/*
7356 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7357 * Free the memory. No need to send any response to PE in this case
7358 */
7359void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7360{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7361 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7362
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7364 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7365
7366 if(NULL == pWdaParams)
7367 {
7368 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7369 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7370 VOS_ASSERT(0) ;
7371 return ;
7372 }
7373
7374 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7375 vos_mem_free(pWdaParams->wdaMsgParam) ;
7376 vos_mem_free(pWdaParams);
7377
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7378 /*
7379 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7380 * so just free the request param here
7381 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7382 return ;
7383}
7384
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7385/*
7386 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7387 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7388 */
7389VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7390 tP2pPsParams *pP2pPsConfigParams)
7391{
7392 WDI_Status status = WDI_STATUS_SUCCESS ;
7393 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7394 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7395 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7396 tWDA_ReqParams *pWdaParams = NULL;
7397
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7399 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7400 if(NULL == wdiSetP2PGONOAReqParam)
7401 {
7402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7403 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7404 VOS_ASSERT(0);
7405 return VOS_STATUS_E_NOMEM;
7406 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7407
7408 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7409 if(NULL == pWdaParams)
7410 {
7411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7412 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7413 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7414 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7415 VOS_ASSERT(0);
7416 return VOS_STATUS_E_NOMEM;
7417 }
7418
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7419 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7420 pP2pPsConfigParams->opp_ps;
7421 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7422 pP2pPsConfigParams->ctWindow;
7423 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7424 pP2pPsConfigParams->count;
7425 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7426 pP2pPsConfigParams->duration;
7427 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7428 pP2pPsConfigParams->interval;
7429 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7430 pP2pPsConfigParams->single_noa_duration;
7431 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7432 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7433
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7434 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7435 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7436 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7437
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7438 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7439 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7440 pWdaParams->pWdaContext = pWDA;
7441
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7442 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7443 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7444
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7445 if(IS_WDI_STATUS_FAILURE(status))
7446 {
7447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7448 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7449 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7450 vos_mem_free(pWdaParams->wdaMsgParam);
7451 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7452 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7453 return CONVERT_WDI2VOS_STATUS(status);
7454
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7455}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7456
7457#ifdef FEATURE_WLAN_TDLS
7458/*
7459 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7460 * Free the memory. No need to send any response to PE in this case
7461 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7462void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7463 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7464{
7465 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7466 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7467 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7468
7469
7470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7471 "<------ %s " ,__func__);
7472 if(NULL == pWdaParams)
7473 {
7474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7475 "%s: pWdaParams received NULL", __func__);
7476 VOS_ASSERT(0) ;
7477 return ;
7478 }
7479 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7480
7481 if(NULL == pWdaParams)
7482 {
7483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7484 "%s: pWdaParams received NULL", __func__);
7485 VOS_ASSERT(0) ;
7486 return ;
7487 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7488 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7489 if( NULL == pTdlsLinkEstablishParams )
7490 {
7491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7492 "%s: pTdlsLinkEstablishParams "
7493 "received NULL " ,__func__);
7494 VOS_ASSERT(0);
7495 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7496 vos_mem_free(pWdaParams);
7497 return ;
7498 }
7499 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7500 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7501 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7502 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7503 /* send response to UMAC*/
7504 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7505
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7506 return ;
7507}
7508
7509VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7510 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7511{
7512 WDI_Status status = WDI_STATUS_SUCCESS ;
7513 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7514 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7515 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7516 tWDA_ReqParams *pWdaParams = NULL;
7517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7518 "------> %s " ,__func__);
7519 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7520 {
7521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7522 "%s: VOS MEM Alloc Failure", __func__);
7523 VOS_ASSERT(0);
7524 return VOS_STATUS_E_NOMEM;
7525 }
7526 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7527 if(NULL == pWdaParams)
7528 {
7529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7530 "%s: VOS MEM Alloc Failure", __func__);
7531 vos_mem_free(pTdlsLinkEstablishParams);
7532 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7533 VOS_ASSERT(0);
7534 return VOS_STATUS_E_NOMEM;
7535 }
7536 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7537 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7538 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7539 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7540 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7541 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7542 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7543 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7544 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7545 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7546 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7547 pTdlsLinkEstablishParams->isOffChannelSupported;
7548
7549 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7550 pTdlsLinkEstablishParams->validChannels,
7551 pTdlsLinkEstablishParams->validChannelsLen);
7552
7553 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7554 pTdlsLinkEstablishParams->validChannelsLen;
7555
7556 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7557 pTdlsLinkEstablishParams->validOperClasses,
7558 pTdlsLinkEstablishParams->validOperClassesLen);
7559 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7560 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7561
7562 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7563 /* Store msg pointer from PE, as this will be used for response */
7564 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7565 /* store Params pass it to WDI */
7566 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7567 pWdaParams->pWdaContext = pWDA;
7568
7569 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7570 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7571 WDA_SetTDLSLinkEstablishReqParamsCallback,
7572 pWdaParams);
7573 if(IS_WDI_STATUS_FAILURE(status))
7574 {
7575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7576 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7577 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7578 vos_mem_free(pWdaParams->wdaMsgParam);
7579 vos_mem_free(pWdaParams);
7580 }
7581 return CONVERT_WDI2VOS_STATUS(status);
7582}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7583
7584// tdlsoffchan
7585void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
7586 void* pUserData)
7587{
7588 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7589 tWDA_CbContext *pWDA = NULL;
7590 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
7591
7592
7593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7594 "<------ %s " ,__func__);
7595 if(NULL == pWdaParams)
7596 {
7597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7598 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7599 VOS_ASSERT(0) ;
7600 return ;
7601 }
7602 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7603
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7604 if(NULL == pWdaParams)
7605 {
7606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7607 "%s: pWdaParams received NULL", __func__);
7608 VOS_ASSERT(0) ;
7609 return ;
7610 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7611 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7612 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7613 {
7614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7615 "%s: pTdlsChanSwitchParams "
7616 "received NULL " ,__func__);
7617 VOS_ASSERT(0);
7618 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7619 vos_mem_free(pWdaParams);
7620 return ;
7621 }
7622 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
7623 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7624 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7625 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7626 /* send response to UMAC*/
7627 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7628
7629 return ;
7630}
7631VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
7632 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
7633{
7634 WDI_Status status = WDI_STATUS_SUCCESS ;
7635 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
7636 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
7637 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
7638 tWDA_ReqParams *pWdaParams = NULL;
7639
7640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7641 "Enter: %s ",__func__);
7642 if(NULL == wdiSetTDLSChanSwitchReqParam)
7643 {
7644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7645 "%s: VOS MEM Alloc Failure", __func__);
7646 VOS_ASSERT(0);
7647 return VOS_STATUS_E_NOMEM;
7648 }
7649
7650 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7651 if(NULL == pWdaParams)
7652 {
7653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7654 "%s: VOS MEM Alloc Failure", __func__);
7655 vos_mem_free(pTdlsChanSwitchParams);
7656 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
7657 VOS_ASSERT(0);
7658 return VOS_STATUS_E_NOMEM;
7659 }
7660 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
7661 pTdlsChanSwitchParams->staIdx;
7662 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
7663 pTdlsChanSwitchParams->tdlsSwMode;
7664 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
7665 pTdlsChanSwitchParams->operClass;
7666 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
7667 pTdlsChanSwitchParams->tdlsOffCh;
7668 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
7669 pTdlsChanSwitchParams->tdlsOffChBwOffset;
7670
7671
7672 /* Store msg pointer from PE, as this will be used for response */
7673 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
7674 /* store Params pass it to WDI */
7675 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
7676 pWdaParams->pWdaContext = pWDA;
7677 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
7678 (WDI_SetTDLSChanSwitchReqParamsRspCb)
7679 WDA_SetTDLSChanSwitchReqParamsCallback,
7680 pWdaParams);
7681 if(IS_WDI_STATUS_FAILURE(status))
7682 {
7683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7684 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
7685 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7686 vos_mem_free(pWdaParams->wdaMsgParam);
7687 vos_mem_free(pWdaParams);
7688 }
7689 return CONVERT_WDI2VOS_STATUS(status);
7690}
7691#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7692
7693
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7694#ifdef WLAN_FEATURE_VOWIFI_11R
7695/*
7696 * FUNCTION: WDA_AggrAddTSReqCallback
7697 * send ADD AGGREGATED TS RSP back to PE
7698 */
7699void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7700{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7701 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7702 tWDA_CbContext *pWDA;
7703 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7704 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7706 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7707 if(NULL == pWdaParams)
7708 {
7709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7710 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7711 VOS_ASSERT(0) ;
7712 return ;
7713 }
7714
7715 pWDA = pWdaParams->pWdaContext;
7716 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7717
7718 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7719 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7720 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7721 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7722 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7723
7724 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7725 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7726 return ;
7727}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7728/*
7729 * FUNCTION: WDA_ProcessAddTSReq
7730 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7731 */
7732VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7733 tAggrAddTsParams *pAggrAddTsReqParams)
7734{
7735 WDI_Status status = WDI_STATUS_SUCCESS ;
7736 int i;
7737 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7738 tWDA_ReqParams *pWdaParams = NULL;
7739
7740
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7742 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7743 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7744 sizeof(WDI_AggrAddTSReqParamsType)) ;
7745 if(NULL == wdiAggrAddTSReqParam)
7746 {
7747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7748 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7749 VOS_ASSERT(0);
7750 return VOS_STATUS_E_NOMEM;
7751 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7752
7753
7754 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7755 if(NULL == pWdaParams)
7756 {
7757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7758 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7759 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7760 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7761 VOS_ASSERT(0);
7762 return VOS_STATUS_E_NOMEM;
7763 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7764 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7765 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7766 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7767 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7768 {
7769 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7770 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7771 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7772 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7773 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7774 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7775 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7776 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7777 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7778 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7779 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7780 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7781 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7782 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7783 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7784 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7785 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7786 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7787 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7788 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7789 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7790 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7791 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7792 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7793 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7794 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7795 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7796 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7797 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7798 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7799 pAggrAddTsReqParams->tspec[i].inactInterval;
7800 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7801 pAggrAddTsReqParams->tspec[i].suspendInterval;
7802 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7803 pAggrAddTsReqParams->tspec[i].svcStartTime;
7804 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7805 pAggrAddTsReqParams->tspec[i].minDataRate;
7806 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7807 pAggrAddTsReqParams->tspec[i].meanDataRate;
7808 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7809 pAggrAddTsReqParams->tspec[i].peakDataRate;
7810 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7811 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7812 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7813 pAggrAddTsReqParams->tspec[i].delayBound;
7814 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7815 pAggrAddTsReqParams->tspec[i].minPhyRate;
7816 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7817 pAggrAddTsReqParams->tspec[i].surplusBw;
7818 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7819 pAggrAddTsReqParams->tspec[i].mediumTime;
7820 }
7821
7822 /* TODO: tAggrAddTsParams doesn't have the following fields */
7823#if 0
7824 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7825 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7826 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7827 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7828#endif
7829 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7830
7831 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7832 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7833 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7834 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7835
7836 pWdaParams->pWdaContext = pWDA;
7837
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7838 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7839 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7840
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7841 if(IS_WDI_STATUS_FAILURE(status))
7842 {
7843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7844 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7845 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7846 vos_mem_free(pWdaParams);
7847
7848 /* send the failure response back to PE*/
7849 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7850 {
7851 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7852 }
7853
7854 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7855 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7856 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7857 return CONVERT_WDI2VOS_STATUS(status) ;
7858}
7859#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7860/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7861 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7862 * send Enter IMPS RSP back to PE
7863 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7864void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7865{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7866 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7867 tWDA_CbContext *pWDA;
7868
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7870 "<------ %s status=%d" ,__func__,status);
7871 if(NULL == pWdaParams)
7872 {
7873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7874 "%s: pWdaParams received NULL", __func__);
7875 VOS_ASSERT(0);
7876 return;
7877 }
7878
7879 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7880
7881 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7882 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7883 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7884 return ;
7885}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7886
7887
7888/*
7889 * FUNCTION: WDA_EnterImpsReqCallback
7890 * Free memory and send Enter IMPS RSP back to PE.
7891 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7892 */
7893void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7894{
7895 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7896 tWDA_CbContext *pWDA;
7897
7898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7899 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7900
7901 if(NULL == pWdaParams)
7902 {
7903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7904 "%s: pWdaParams received NULL", __func__);
7905 VOS_ASSERT(0);
7906 return;
7907 }
7908
7909 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7910
7911 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7912 {
7913 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7914 vos_mem_free(pWdaParams);
7915 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7916 CONVERT_WDI2SIR_STATUS(wdiStatus));
7917 }
7918
7919 return;
7920}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7921/*
7922 * FUNCTION: WDA_ProcessEnterImpsReq
7923 * Request to WDI to Enter IMPS power state.
7924 */
7925VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7926{
7927 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7928 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7929 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7931 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7932
7933
7934 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7935 if (NULL == wdiEnterImpsReqParams)
7936 {
7937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7938 "%s: VOS MEM Alloc Failure", __func__);
7939 VOS_ASSERT(0);
7940 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7941 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7942 return VOS_STATUS_E_NOMEM;
7943 }
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_ASSERT(0);
7951 vos_mem_free(wdiEnterImpsReqParams);
7952 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7953 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7954 return VOS_STATUS_E_NOMEM;
7955 }
7956
7957 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7958 wdiEnterImpsReqParams->pUserData = pWdaParams;
7959
7960 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7961 pWdaParams->wdaMsgParam = NULL;
7962 pWdaParams->pWdaContext = pWDA;
7963
7964 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7965 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7966 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7967 if(IS_WDI_STATUS_FAILURE(status))
7968 {
7969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7970 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7971 vos_mem_free(wdiEnterImpsReqParams);
7972 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7973 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7974 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7975 return CONVERT_WDI2VOS_STATUS(status) ;
7976}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7977/*
7978 * FUNCTION: WDA_ExitImpsReqCallback
7979 * send Exit IMPS RSP back to PE
7980 */
7981void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7982{
7983 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7985 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7986 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7987 return ;
7988}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7989/*
7990 * FUNCTION: WDA_ProcessExitImpsReq
7991 * Request to WDI to Exit IMPS power state.
7992 */
7993VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7994{
7995 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7996 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7997 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7998 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7999 if(IS_WDI_STATUS_FAILURE(status))
8000 {
8001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8002 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8003 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8004 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8005 return CONVERT_WDI2VOS_STATUS(status) ;
8006}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8007/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8008 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8009 * send Enter BMPS RSP back to PE
8010 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8011void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8012{
8013 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8014 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8015 tEnterBmpsParams *pEnterBmpsRspParams;
8016
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8017 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8018 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8019 if(NULL == pWdaParams)
8020 {
8021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8022 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8023 VOS_ASSERT(0) ;
8024 return ;
8025 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8026
8027 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8028 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8029
8030 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8031 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8032
8033 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8034 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8035 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
8036
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8037 return ;
8038}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8039/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8040 * FUNCTION: WDA_EnterBmpsReqCallback
8041 * Free memory and send Enter BMPS RSP back to PE.
8042 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
8043 */
8044void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8045{
8046 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8047 tWDA_CbContext *pWDA;
8048 tEnterBmpsParams *pEnterBmpsRspParams;
8049
8050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8051 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8052
8053 if(NULL == pWdaParams)
8054 {
8055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8056 "%s: pWdaParams received NULL", __func__);
8057 VOS_ASSERT(0);
8058 return;
8059 }
8060
8061 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8062 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8063 pEnterBmpsRspParams->status = wdiStatus;
8064
8065 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8066 {
8067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8068 vos_mem_free(pWdaParams);
8069 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
8070 }
8071
8072 return;
8073}
8074/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8075 * FUNCTION: WDA_ProcessEnterBmpsReq
8076 * Request to WDI to Enter BMPS power state.
8077 */
8078VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
8079 tEnterBmpsParams *pEnterBmpsReqParams)
8080{
8081 WDI_Status status = WDI_STATUS_SUCCESS;
8082 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
8083 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8085 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8086 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
8087 {
8088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8089 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8090 VOS_ASSERT(0);
8091 return VOS_STATUS_E_FAILURE;
8092 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8093 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
8094 if (NULL == wdiEnterBmpsReqParams)
8095 {
8096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8097 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8098 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8099 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8100 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8101 return VOS_STATUS_E_NOMEM;
8102 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8103 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8104 if (NULL == pWdaParams)
8105 {
8106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8107 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8108 VOS_ASSERT(0);
8109 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8110 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8111 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8112 return VOS_STATUS_E_NOMEM;
8113 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8114 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
8115 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
8116 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
8117 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]8118 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8119 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
8120 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
8121 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8122 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
8123 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8124
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8125 /* Store param pointer as passed in by caller */
8126 /* store Params pass it to WDI */
8127 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8128 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8129 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8130 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8131 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8132 if (IS_WDI_STATUS_FAILURE(status))
8133 {
8134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8135 "Failure in Enter BMPS REQ WDI API, free all the memory" );
8136 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8137 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8138 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8139 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8140 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8141 return CONVERT_WDI2VOS_STATUS(status);
8142}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8143
8144
8145static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
8146 WDI_Status wdiStatus,
8147 tExitBmpsParams *pExitBmpsReqParams)
8148{
8149 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
8150
8151 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
8152}
8153
8154
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8155/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8156 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8157 * send Exit BMPS RSP back to PE
8158 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8159void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8160{
8161 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8162 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8163 tExitBmpsParams *pExitBmpsRspParams;
8164
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8166 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8167 if(NULL == pWdaParams)
8168 {
8169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8170 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8171 VOS_ASSERT(0) ;
8172 return ;
8173 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8174
8175 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8176 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8177
8178 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8179 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8180
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8182 vos_mem_free(pWdaParams) ;
8183
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8184 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8185 return ;
8186}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8187/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8188 * FUNCTION: WDA_ExitBmpsReqCallback
8189 * Free memory and send Exit BMPS RSP back to PE.
8190 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
8191 */
8192void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8193{
8194 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8195 tWDA_CbContext *pWDA;
8196 tExitBmpsParams *pExitBmpsRspParams;
8197
8198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8199 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8200
8201 if(NULL == pWdaParams)
8202 {
8203 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8204 "%s: pWdaParams received NULL", __func__);
8205 VOS_ASSERT(0);
8206 return;
8207 }
8208
8209 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8210 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8211 pExitBmpsRspParams->status = wdiStatus;
8212
8213 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8214 {
8215 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8216 vos_mem_free(pWdaParams);
8217 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
8218 }
8219
8220 return;
8221}
8222/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8223 * FUNCTION: WDA_ProcessExitBmpsReq
8224 * Request to WDI to Exit BMPS power state.
8225 */
8226VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
8227 tExitBmpsParams *pExitBmpsReqParams)
8228{
8229 WDI_Status status = WDI_STATUS_SUCCESS ;
8230 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
8231 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
8232 sizeof(WDI_ExitBmpsReqParamsType)) ;
8233 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8235 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8236 if(NULL == wdiExitBmpsReqParams)
8237 {
8238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8239 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8240 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8241 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8242 return VOS_STATUS_E_NOMEM;
8243 }
8244 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8245 if(NULL == pWdaParams)
8246 {
8247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8248 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8249 VOS_ASSERT(0);
8250 vos_mem_free(wdiExitBmpsReqParams);
8251 return VOS_STATUS_E_NOMEM;
8252 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8253 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8254
8255 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
8256
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8257 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
8258 wdiExitBmpsReqParams->pUserData = pWdaParams;
8259
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8260 /* Store param pointer as passed in by caller */
8261 /* store Params pass it to WDI */
8262 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
8263 pWdaParams->pWdaContext = pWDA;
8264 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8265 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8266 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8267 if(IS_WDI_STATUS_FAILURE(status))
8268 {
8269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8270 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8271 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8272 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8273 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8274 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8275 return CONVERT_WDI2VOS_STATUS(status) ;
8276}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8277/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8278 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8279 * send Enter UAPSD RSP back to PE
8280 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8281void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8282{
8283 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8284 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8285 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8286 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8287 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8288 if(NULL == pWdaParams)
8289 {
8290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8291 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8292 VOS_ASSERT(0) ;
8293 return ;
8294 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8295
8296 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8297 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8298
8299 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8300 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8302 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8303 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8304 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8305 return ;
8306}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8307/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8308 * FUNCTION: WDA_EnterUapsdReqCallback
8309 * Free memory and send Enter UAPSD RSP back to PE.
8310 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8311 */
8312void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8313{
8314 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8315 tWDA_CbContext *pWDA;
8316 tUapsdParams *pEnterUapsdRsqParams;
8317
8318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8319 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8320
8321 if(NULL == pWdaParams)
8322 {
8323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8324 "%s: pWdaParams received NULL", __func__);
8325 VOS_ASSERT(0);
8326 return;
8327 }
8328
8329 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8330 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8331 pEnterUapsdRsqParams->status = wdiStatus;
8332
8333 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8334 {
8335 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8336 vos_mem_free(pWdaParams);
8337 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8338 }
8339
8340 return;
8341}
8342/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8343 * FUNCTION: WDA_ProcessEnterUapsdReq
8344 * Request to WDI to Enter UAPSD power state.
8345 */
8346VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8347 tUapsdParams *pEnterUapsdReqParams)
8348{
8349 WDI_Status status = WDI_STATUS_SUCCESS ;
8350 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8351 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8352 sizeof(WDI_EnterUapsdReqParamsType)) ;
8353 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8355 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8356 if(NULL == wdiEnterUapsdReqParams)
8357 {
8358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8359 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8360 VOS_ASSERT(0);
8361 return VOS_STATUS_E_NOMEM;
8362 }
8363 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8364 if(NULL == pWdaParams)
8365 {
8366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8367 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8368 VOS_ASSERT(0);
8369 vos_mem_free(wdiEnterUapsdReqParams);
8370 return VOS_STATUS_E_NOMEM;
8371 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8372 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8373 pEnterUapsdReqParams->beDeliveryEnabled;
8374 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8375 pEnterUapsdReqParams->beTriggerEnabled;
8376 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8377 pEnterUapsdReqParams->bkDeliveryEnabled;
8378 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8379 pEnterUapsdReqParams->bkTriggerEnabled;
8380 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8381 pEnterUapsdReqParams->viDeliveryEnabled;
8382 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8383 pEnterUapsdReqParams->viTriggerEnabled;
8384 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8385 pEnterUapsdReqParams->voDeliveryEnabled;
8386 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8387 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8388 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8389
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8390 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8391 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8392
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8393 /* Store param pointer as passed in by caller */
8394 /* store Params pass it to WDI */
8395 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8396 pWdaParams->pWdaContext = pWDA;
8397 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8398 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8399 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8400 if(IS_WDI_STATUS_FAILURE(status))
8401 {
8402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8403 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8404 vos_mem_free(pWdaParams->wdaMsgParam) ;
8405 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8406 vos_mem_free(pWdaParams) ;
8407 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8408 return CONVERT_WDI2VOS_STATUS(status) ;
8409}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8410/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8411 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8412 * send Exit UAPSD RSP back to PE
8413 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8414void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8415{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8416
8417 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8418 tWDA_CbContext *pWDA;
8419 tExitUapsdParams *pExitUapsdRspParams;
8420
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8422 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8423 if(NULL == pWdaParams)
8424 {
8425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8426 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8427 VOS_ASSERT(0);
8428 return;
8429 }
8430
8431 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8432 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8433
8434 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8435 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8436
8437 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8438 vos_mem_free(pWdaParams) ;
8439
8440 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8441 return ;
8442}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8443/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8444 * FUNCTION: WDA_ExitUapsdReqCallback
8445 * Free memory and send Exit UAPSD RSP back to PE.
8446 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8447 */
8448void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8449{
8450 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8451 tWDA_CbContext *pWDA;
8452 tExitUapsdParams *pExitUapsdRspParams;
8453
8454 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8455 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8456
8457 if(NULL == pWdaParams)
8458 {
8459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8460 "%s: pWdaParams received NULL", __func__);
8461 VOS_ASSERT(0);
8462 return;
8463 }
8464
8465 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8466 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8467 pExitUapsdRspParams->status = wdiStatus;
8468
8469 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8470 {
8471 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8472 vos_mem_free(pWdaParams);
8473 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8474 }
8475
8476 return;
8477}
8478/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8479 * FUNCTION: WDA_ProcessExitUapsdReq
8480 * Request to WDI to Exit UAPSD power state.
8481 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8482VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8483 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8484{
8485 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8486 tWDA_ReqParams *pWdaParams ;
8487 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8488 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8489 sizeof(WDI_ExitUapsdReqParamsType)) ;
8490
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8492 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8493
8494 if(NULL == wdiExitUapsdReqParams)
8495 {
8496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8497 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8498 VOS_ASSERT(0);
8499 return VOS_STATUS_E_NOMEM;
8500 }
8501 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8502 if(NULL == pWdaParams)
8503 {
8504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8505 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8506 VOS_ASSERT(0);
8507 vos_mem_free(wdiExitUapsdReqParams);
8508 return VOS_STATUS_E_NOMEM;
8509 }
8510
8511 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8512 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8513 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8514
8515 /* Store param pointer as passed in by caller */
8516 /* store Params pass it to WDI */
8517 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8518 pWdaParams->pWdaContext = pWDA;
8519 pWdaParams->wdaMsgParam = pExitUapsdParams;
8520
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8521 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8522 if(IS_WDI_STATUS_FAILURE(status))
8523 {
8524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8525 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8526 vos_mem_free(pWdaParams->wdaMsgParam) ;
8527 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8528 vos_mem_free(pWdaParams) ;
8529
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8531 return CONVERT_WDI2VOS_STATUS(status) ;
8532}
8533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8534/*
8535 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8536 *
8537 */
8538void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8539{
8540 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8542 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8543 if(NULL == pWdaParams)
8544 {
8545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8546 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8547 VOS_ASSERT(0) ;
8548 return ;
8549 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8550 if( pWdaParams != NULL )
8551 {
8552 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8553 {
8554 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8555 }
8556 if( pWdaParams->wdaMsgParam != NULL )
8557 {
8558 vos_mem_free(pWdaParams->wdaMsgParam) ;
8559 }
8560 vos_mem_free(pWdaParams) ;
8561 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8562 return ;
8563}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8564/*
8565 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8566 * Request to WDI to set the power save params at start.
8567 */
8568VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8569 tSirPowerSaveCfg *pPowerSaveCfg)
8570{
8571 WDI_Status status = WDI_STATUS_SUCCESS ;
8572 tHalCfg *tlvStruct = NULL ;
8573 tANI_U8 *tlvStructStart = NULL ;
8574 v_PVOID_t *configParam;
8575 tANI_U32 configParamSize;
8576 tANI_U32 *configDataValue;
8577 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8578 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8580 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8581 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8582 {
8583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8584 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8585 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8586 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8587 return VOS_STATUS_E_FAILURE;
8588 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8589 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8590 if (NULL == wdiPowerSaveCfg)
8591 {
8592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8593 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8594 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8595 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8596 return VOS_STATUS_E_NOMEM;
8597 }
8598 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8599 if(NULL == pWdaParams)
8600 {
8601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8602 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8603 VOS_ASSERT(0);
8604 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8605 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8606 return VOS_STATUS_E_NOMEM;
8607 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8608 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8609 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8610 if(NULL == configParam)
8611 {
8612 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8613 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8614 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8615 vos_mem_free(pWdaParams);
8616 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8617 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8618 return VOS_STATUS_E_NOMEM;
8619 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8620 vos_mem_set(configParam, configParamSize, 0);
8621 wdiPowerSaveCfg->pConfigBuffer = configParam;
8622 tlvStruct = (tHalCfg *)configParam;
8623 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8624 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8625 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8626 tlvStruct->length = sizeof(tANI_U32);
8627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8628 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8629 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8630 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8631 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8632 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8633 tlvStruct->length = sizeof(tANI_U32);
8634 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8635 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8636 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8637 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8638 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8639 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8640 tlvStruct->length = sizeof(tANI_U32);
8641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8642 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8643 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8644 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8645 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8646 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8647 tlvStruct->length = sizeof(tANI_U32);
8648 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8649 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8650 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8651 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8652 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8653 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8654 tlvStruct->length = sizeof(tANI_U32);
8655 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8656 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8657 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8658 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8659 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8660 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8661 tlvStruct->length = sizeof(tANI_U32);
8662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8663 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8664 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8665 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8666 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8667 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8668 tlvStruct->length = sizeof(tANI_U32);
8669 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8670 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8671 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8672 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8673 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8674 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8675 tlvStruct->length = sizeof(tANI_U32);
8676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8677 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8678 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8679 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8680 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8681 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8682 tlvStruct->length = sizeof(tANI_U32);
8683 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8684 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8685 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8686 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8687 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8688 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8689 tlvStruct->length = sizeof(tANI_U32);
8690 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8691 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8692 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8693 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8694 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8695 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8696 tlvStruct->length = sizeof(tANI_U32);
8697 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8698 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8699 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8700 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8701 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8702 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8703 /* store Params pass it to WDI */
8704 pWdaParams->wdaMsgParam = configParam;
8705 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8706 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8707 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8708 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8709 if(IS_WDI_STATUS_FAILURE(status))
8710 {
8711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8712 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8713 vos_mem_free(pWdaParams->wdaMsgParam);
8714 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8715 vos_mem_free(pWdaParams);
8716 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8717 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8718 return CONVERT_WDI2VOS_STATUS(status);
8719}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8720/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8721 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8722 *
8723 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8724void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8725{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8726 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8727
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8729 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8730
8731 if(NULL == pWdaParams)
8732 {
8733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8734 "%s: pWdaParams received NULL", __func__);
8735 VOS_ASSERT(0);
8736 return ;
8737 }
8738
8739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8740 vos_mem_free(pWdaParams);
8741
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8742 return ;
8743}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8744/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8745 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8746 * Free memory.
8747 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8748 */
8749void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8750{
8751 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8752
8753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8754 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8755
8756 if(NULL == pWdaParams)
8757 {
8758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8759 "%s: pWdaParams received NULL", __func__);
8760 VOS_ASSERT(0);
8761 return;
8762 }
8763
8764 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8765 {
8766 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8767 vos_mem_free(pWdaParams);
8768 }
8769
8770 return;
8771}
8772/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8773 * FUNCTION: WDA_SetUapsdAcParamsReq
8774 * Request to WDI to set the UAPSD params for an ac (sta mode).
8775 */
8776VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8777 tUapsdInfo *pUapsdInfo)
8778{
8779 WDI_Status status = WDI_STATUS_SUCCESS;
8780 tWDA_CbContext *pWDA = NULL ;
8781 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8782 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8783 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8784 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8786 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8787 if(NULL == wdiUapsdParams)
8788 {
8789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8790 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8791 VOS_ASSERT(0);
8792 return VOS_STATUS_E_NOMEM;
8793 }
8794 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8795 if(NULL == pWdaParams)
8796 {
8797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8798 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8799 VOS_ASSERT(0);
8800 vos_mem_free(wdiUapsdParams);
8801 return VOS_STATUS_E_NOMEM;
8802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8803 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8804 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8805 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8806 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8807 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8808 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8809 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8810 wdiUapsdParams->pUserData = pWdaParams;
8811
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8812 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8813 pWdaParams->pWdaContext = pWDA;
8814 /* Store param pointer as passed in by caller */
8815 pWdaParams->wdaMsgParam = pUapsdInfo;
8816 /* store Params pass it to WDI */
8817 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8818 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8819 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8820 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8821 if(IS_WDI_STATUS_FAILURE(status))
8822 {
8823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8824 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8825 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8826 vos_mem_free(pWdaParams);
8827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8828 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8829 return VOS_STATUS_SUCCESS;
8830 else
8831 return VOS_STATUS_E_FAILURE;
8832
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8833}
8834/*
8835 * FUNCTION: WDA_ClearUapsdAcParamsReq
8836 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8837 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8838 * and again enter the UPASD with the modified params. Hence the disable
8839 * function was kept empty.
8840 *
8841 */
8842VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8843{
8844 /* do nothing */
8845 return VOS_STATUS_SUCCESS;
8846}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8847/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8848 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8849 *
8850 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8851void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8852{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8853 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8854
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8856 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8857
8858 if(NULL == pWdaParams)
8859 {
8860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8861 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8862 VOS_ASSERT(0) ;
8863 return ;
8864 }
8865
8866 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8867 vos_mem_free(pWdaParams->wdaMsgParam);
8868 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8869
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8870 //print a msg, nothing else to do
8871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8872 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8873 return ;
8874}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8875/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8876 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8877 * Free memory.
8878 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8879 */
8880void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8881{
8882 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8883
8884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8885 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8886
8887 if(NULL == pWdaParams)
8888 {
8889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8890 "%s: pWdaParams received NULL", __func__);
8891 VOS_ASSERT(0);
8892 return;
8893 }
8894
8895 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8896 {
8897 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8898 vos_mem_free(pWdaParams->wdaMsgParam);
8899 vos_mem_free(pWdaParams);
8900 }
8901
8902 return;
8903}
8904/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8905 * FUNCTION: WDA_UpdateUapsdParamsReq
8906 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8907 */
8908VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8909 tUpdateUapsdParams* pUpdateUapsdInfo)
8910{
8911 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8912 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8913 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8914 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8915 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8916 tWDA_ReqParams *pWdaParams = NULL;
8917
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8918 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8919 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8920 if(NULL == wdiUpdateUapsdParams)
8921 {
8922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8923 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8924 VOS_ASSERT(0);
8925 return VOS_STATUS_E_NOMEM;
8926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8927 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8928 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8929 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8930 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8931 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8932
8933 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8934 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8935 {
8936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8937 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8938 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8939 vos_mem_free(pUpdateUapsdInfo);
8940 vos_mem_free(wdiUpdateUapsdParams);
8941 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8942 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8943 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8944 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8945 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8946 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8947 pWdaParams->pWdaContext = pWDA;
8948
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8949 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8950 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8951 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8952
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8953 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8954 {
8955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8956 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8957 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8958 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8959 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8960 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8961 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8962 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8963}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8964/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8965 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8966 *
8967 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8968void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8969{
8970 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8972 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8973 if(WDI_STATUS_SUCCESS != wdiStatus)
8974 {
8975 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8976 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8977 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8978 if(NULL == pWdaParams)
8979 {
8980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8981 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8982 VOS_ASSERT(0) ;
8983 return ;
8984 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8985 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8986 vos_mem_free(pWdaParams->wdaMsgParam);
8987 vos_mem_free(pWdaParams);
8988 return ;
8989}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8990/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8991 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8992 * Free memory.
8993 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8994 */
8995void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8996{
8997 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8998
8999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9000 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9001
9002 if(NULL == pWdaParams)
9003 {
9004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9005 "%s: pWdaParams received NULL", __func__);
9006 VOS_ASSERT(0);
9007 return;
9008 }
9009
9010 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9011 {
9012 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9013 vos_mem_free(pWdaParams->wdaMsgParam);
9014 vos_mem_free(pWdaParams);
9015 }
9016
9017 return;
9018}
9019/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9020 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
9021 *
9022 */
9023VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
9024 tSirWlanSetRxpFilters *pWlanSuspendParam)
9025{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9026 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9027 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9028 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9029 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9030 /* Sanity Check
9031 * This is very unlikely and add assert to collect more info next time */
9032 if(NULL == pWlanSuspendParam)
9033 {
9034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9035 "%s: pWlanSuspendParam received NULL", __func__);
9036 VOS_ASSERT(0) ;
9037 return VOS_STATUS_E_FAULT;
9038 }
9039 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
9040 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9042 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9043 if(NULL == wdiRxpFilterParams)
9044 {
9045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9047 VOS_ASSERT(0);
9048 vos_mem_free(pWlanSuspendParam);
9049 return VOS_STATUS_E_NOMEM;
9050 }
9051 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9052 if(NULL == pWdaParams)
9053 {
9054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9055 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9056 VOS_ASSERT(0);
9057 vos_mem_free(wdiRxpFilterParams);
9058 vos_mem_free(pWlanSuspendParam);
9059 return VOS_STATUS_E_NOMEM;
9060 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9061 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
9062 pWlanSuspendParam->setMcstBcstFilter;
9063 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
9064 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9065
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9066 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
9067 wdiRxpFilterParams->pUserData = pWdaParams;
9068
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9069 pWdaParams->pWdaContext = pWDA;
9070 pWdaParams->wdaMsgParam = pWlanSuspendParam;
9071 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9072 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9073 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9074 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9075 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9076 {
9077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9078 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9079 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9080 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9081 vos_mem_free(pWdaParams->wdaMsgParam);
9082 vos_mem_free(pWdaParams);
9083 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9084 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9085}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9086/*
9087 * FUNCTION: WDA_WdiIndicationCallback
9088 *
9089 */
9090void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
9091 void* pUserData)
9092{
9093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9094 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9095}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9096/*
9097 * FUNCTION: WDA_ProcessWlanSuspendInd
9098 *
9099 */
9100VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
9101 tSirWlanSuspendParam *pWlanSuspendParam)
9102{
9103 WDI_Status wdiStatus;
9104 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9106 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9107 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
9108 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9109 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
9110 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9111 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]9112 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
9113 if(WDI_STATUS_PENDING == wdiStatus)
9114 {
9115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9116 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9117 }
9118 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9119 {
9120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9121 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9122 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9123 vos_mem_free(pWlanSuspendParam);
9124 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9125}
9126
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]9127#ifdef WLAN_FEATURE_11W
9128/*
9129 * FUNCTION: WDA_ProcessExcludeUnecryptInd
9130 *
9131 */
9132VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
9133 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
9134{
9135 WDI_Status wdiStatus;
9136 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
9137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9138 "------> %s ", __func__);
9139
9140 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
9141 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
9142 sizeof(tSirMacAddr));
9143
9144 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
9145 wdiExclUnencryptParams.pUserData = pWDA;
9146
9147 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
9148 if(WDI_STATUS_PENDING == wdiStatus)
9149 {
9150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9151 "Pending received for %s:%d ", __func__, __LINE__ );
9152 }
9153 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9154 {
9155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9156 "Failure in %s:%d ", __func__, __LINE__ );
9157 }
9158 vos_mem_free(pExclUnencryptParam);
9159 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9160}
9161#endif
9162
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9163/*
9164 * FUNCTION: WDA_ProcessWlanResumeCallback
9165 *
9166 */
9167void WDA_ProcessWlanResumeCallback(
9168 WDI_SuspendResumeRspParamsType *resumeRspParams,
9169 void* pUserData)
9170{
9171 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9173 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9174 if(NULL == pWdaParams)
9175 {
9176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9177 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9178 VOS_ASSERT(0) ;
9179 return ;
9180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9181 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
9182 {
9183 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9184 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9185 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9187 vos_mem_free(pWdaParams->wdaMsgParam);
9188 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9189 return ;
9190}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9191/*
9192 * FUNCTION: WDA_ProcessWlanResumeReq
9193 *
9194 */
9195VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
9196 tSirWlanResumeParam *pWlanResumeParam)
9197{
9198 WDI_Status wdiStatus;
9199 WDI_ResumeParamsType *wdiResumeParams =
9200 (WDI_ResumeParamsType *)vos_mem_malloc(
9201 sizeof(WDI_ResumeParamsType) ) ;
9202 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9203 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9204 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9205 if(NULL == wdiResumeParams)
9206 {
9207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9208 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9209 VOS_ASSERT(0);
9210 return VOS_STATUS_E_NOMEM;
9211 }
9212 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9213 if(NULL == pWdaParams)
9214 {
9215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9216 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9217 VOS_ASSERT(0);
9218 vos_mem_free(wdiResumeParams);
9219 return VOS_STATUS_E_NOMEM;
9220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9221 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
9222 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9223 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]9224 wdiResumeParams->wdiReqStatusCB = NULL;
9225 pWdaParams->wdaMsgParam = pWlanResumeParam;
9226 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
9227 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9228 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
9229 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
9230 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9231 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9232 {
9233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9234 "Failure in Host Resume REQ WDI API, free all the memory " );
9235 VOS_ASSERT(0);
9236 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9237 vos_mem_free(pWdaParams->wdaMsgParam);
9238 vos_mem_free(pWdaParams);
9239 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9240 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9241}
9242
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9243/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9244 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9245 *
9246 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9247void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9248{
9249 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9251 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9252 if(NULL == pWdaParams)
9253 {
9254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9255 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9256 VOS_ASSERT(0) ;
9257 return ;
9258 }
9259
9260 vos_mem_free(pWdaParams->wdaMsgParam) ;
9261 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9262 vos_mem_free(pWdaParams) ;
9263 /*
9264 * No respone required for SetBeaconFilter req so just free the request
9265 * param here
9266 */
9267
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9268 return ;
9269}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9270/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9271 * FUNCTION: WDA_SetBeaconFilterReqCallback
9272 * Free memory.
9273 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
9274 */
9275void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9276{
9277 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9278
9279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9280 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9281
9282 if(NULL == pWdaParams)
9283 {
9284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9285 "%s: pWdaParams received NULL", __func__);
9286 VOS_ASSERT(0);
9287 return;
9288 }
9289
9290 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9291 {
9292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9293 vos_mem_free(pWdaParams->wdaMsgParam);
9294 vos_mem_free(pWdaParams);
9295 }
9296
9297 return;
9298}
9299/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9300 * FUNCTION: WDA_SetBeaconFilterReq
9301 * Request to WDI to send the beacon filtering related information.
9302 */
9303VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9304 tBeaconFilterMsg* pBeaconFilterInfo)
9305{
9306 WDI_Status status = WDI_STATUS_SUCCESS;
9307 tANI_U8 *dstPtr, *srcPtr;
9308 tANI_U8 filterLength;
9309 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9310 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9311 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9312 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9314 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9315 if(NULL == wdiBeaconFilterInfo)
9316 {
9317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9318 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9319 VOS_ASSERT(0);
9320 return VOS_STATUS_E_NOMEM;
9321 }
9322 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9323 if(NULL == pWdaParams)
9324 {
9325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9326 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9327 VOS_ASSERT(0);
9328 vos_mem_free(wdiBeaconFilterInfo);
9329 return VOS_STATUS_E_NOMEM;
9330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9331 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9332 pBeaconFilterInfo->beaconInterval;
9333 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9334 pBeaconFilterInfo->capabilityInfo;
9335 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9336 pBeaconFilterInfo->capabilityMask;
9337 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9338
9339 //Fill the BssIdx
9340 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9341
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9342 //Fill structure with info contained in the beaconFilterTable
9343 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9344 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9345 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9346 if(WDI_BEACON_FILTER_LEN < filterLength)
9347 {
9348 filterLength = WDI_BEACON_FILTER_LEN;
9349 }
9350 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9351 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9352 wdiBeaconFilterInfo->pUserData = pWdaParams;
9353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9354 /* Store param pointer as passed in by caller */
9355 /* store Params pass it to WDI */
9356 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9357 pWdaParams->pWdaContext = pWDA;
9358 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9359
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9360 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9361 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9362 if(IS_WDI_STATUS_FAILURE(status))
9363 {
9364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9365 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9366 vos_mem_free(pWdaParams->wdaMsgParam) ;
9367 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9368 vos_mem_free(pWdaParams) ;
9369 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9370 return CONVERT_WDI2VOS_STATUS(status) ;
9371}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9372/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9373 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9374 *
9375 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9376void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9377{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9378 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9379
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9381 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9382
9383 if(NULL == pWdaParams)
9384 {
9385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9386 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9387 VOS_ASSERT(0) ;
9388 return ;
9389 }
9390
9391 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9392 vos_mem_free(pWdaParams->wdaMsgParam);
9393 vos_mem_free(pWdaParams);
9394
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9395 //print a msg, nothing else to do
9396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9397 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9398 return ;
9399}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9400/*
9401 * FUNCTION: WDA_RemBeaconFilterReqCallback
9402 * Free memory.
9403 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9404 */
9405void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9406{
9407 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9408
9409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9410 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9411
9412 if(NULL == pWdaParams)
9413 {
9414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9415 "%s: pWdaParams received NULL", __func__);
9416 VOS_ASSERT(0);
9417 return;
9418 }
9419
9420 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9421 {
9422 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9423 vos_mem_free(pWdaParams->wdaMsgParam);
9424 vos_mem_free(pWdaParams);
9425 }
9426
9427 return;
9428}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9429 // TODO: PE does not have this feature for now implemented,
9430 // but the support for removing beacon filter exists between
9431 // HAL and FW. This function can be called whenever PE defines
9432 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9433/*
9434 * FUNCTION: WDA_RemBeaconFilterReq
9435 * Request to WDI to send the removal of beacon filtering related information.
9436 */
9437VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9438 tRemBeaconFilterMsg* pBeaconFilterInfo)
9439{
9440 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9441 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9442 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9443 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9444 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9445 tWDA_ReqParams *pWdaParams ;
9446
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9448 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9449 if(NULL == wdiBeaconFilterInfo)
9450 {
9451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9452 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9453 VOS_ASSERT(0);
9454 return VOS_STATUS_E_NOMEM;
9455 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9456 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9457 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9458 {
9459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9460 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9461 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9462 vos_mem_free(wdiBeaconFilterInfo);
9463 vos_mem_free(pBeaconFilterInfo);
9464 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9465 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9466
9467 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9468 pBeaconFilterInfo->ucIeCount;
9469 //Fill structure with info contained in the ucRemIeId
9470 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9471 pBeaconFilterInfo->ucRemIeId,
9472 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9473 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9474 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9475
9476 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9477 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9478 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9479 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9480
9481 pWdaParams->pWdaContext = pWDA;
9482
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9483 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9484 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9485 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9486 {
9487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9488 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9489 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9490 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9491 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9492 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9493 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9494 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9495}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9496/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9497 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9498 *
9499 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9500void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9501{
9502 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9504 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9505 if(NULL == pWdaParams)
9506 {
9507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9508 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9509 VOS_ASSERT(0) ;
9510 return ;
9511 }
9512
9513 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9514 vos_mem_free(pWdaParams) ;
9515
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9516 return ;
9517}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9518/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9519 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9520 * Free memory.
9521 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9522 */
9523void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9524{
9525 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9526
9527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9528 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9529
9530 if(NULL == pWdaParams)
9531 {
9532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9533 "%s: pWdaParams received NULL", __func__);
9534 VOS_ASSERT(0);
9535 return;
9536 }
9537
9538 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9539 {
9540 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9541 vos_mem_free(pWdaParams);
9542 }
9543
9544 return;
9545}
9546/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9547 * FUNCTION: WDA_SetRSSIThresholdsReq
9548 * Request to WDI to set the RSSI thresholds (sta mode).
9549 */
9550VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9551{
9552 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9553 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9554 tWDA_CbContext *pWDA = NULL ;
9555 v_PVOID_t pVosContext = NULL;
9556 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9557 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9558 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9559 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9561 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9562 if(NULL == wdiRSSIThresholdsInfo)
9563 {
9564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9565 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9566 VOS_ASSERT(0);
9567 return VOS_STATUS_E_NOMEM;
9568 }
9569 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9570 if(NULL == pWdaParams)
9571 {
9572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9573 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9574 VOS_ASSERT(0);
9575 vos_mem_free(wdiRSSIThresholdsInfo);
9576 return VOS_STATUS_E_NOMEM;
9577 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9578 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9579 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9580 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9581 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9582 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9583 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9584 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9585 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9586 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9587 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9588 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9589 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9590 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9591 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9592
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9593 /* Store param pointer as passed in by caller */
9594 /* store Params pass it to WDI */
9595 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9596 pWdaParams->pWdaContext = pWDA;
9597 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9598 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9599 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9600 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9601 {
9602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9603 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9604 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9605 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9606 vos_mem_free(pWdaParams) ;
9607 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9608 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9609
9610}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9611/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9612 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 *
9614 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9615void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9616{
9617 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9618
9619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9620 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9621 if(NULL == pWdaParams)
9622 {
9623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9624 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9625 VOS_ASSERT(0) ;
9626 return ;
9627 }
9628
9629 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9630 vos_mem_free(pWdaParams->wdaMsgParam);
9631 vos_mem_free(pWdaParams) ;
9632
9633 //print a msg, nothing else to do
9634 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9635 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9636 return ;
9637}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9638/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9639 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9640 * Free memory.
9641 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9642 */
9643void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9644{
9645 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9646
9647 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9648 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9649
9650 if(NULL == pWdaParams)
9651 {
9652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9653 "%s: Invalid pWdaParams pointer", __func__);
9654 VOS_ASSERT(0);
9655 return;
9656 }
9657
9658 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9659 {
9660 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9661 vos_mem_free(pWdaParams->wdaMsgParam);
9662 vos_mem_free(pWdaParams);
9663 }
9664
9665 return;
9666}
9667/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9668 * FUNCTION: WDA_ProcessHostOffloadReq
9669 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9670 * to broadcast traffic (sta mode).
9671 */
9672VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9673 tSirHostOffloadReq *pHostOffloadParams)
9674{
9675 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9676 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9677 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9678 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9679 sizeof(WDI_HostOffloadReqParamsType)) ;
9680 tWDA_ReqParams *pWdaParams ;
9681
9682 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9683 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9684
9685 if(NULL == wdiHostOffloadInfo)
9686 {
9687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9688 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9689 VOS_ASSERT(0);
9690 return VOS_STATUS_E_NOMEM;
9691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9692 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9693 if(NULL == pWdaParams)
9694 {
9695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9696 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9697 VOS_ASSERT(0);
9698 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9699 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9700 return VOS_STATUS_E_NOMEM;
9701 }
9702
9703 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9704 pHostOffloadParams->offloadType;
9705 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9706 pHostOffloadParams->enableOrDisable;
9707
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9708 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9709 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9710
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9711 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9712 {
9713 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9714 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9715 pHostOffloadParams->params.hostIpv4Addr,
9716 4);
9717 break;
9718 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9719 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9720 pHostOffloadParams->params.hostIpv6Addr,
9721 16);
9722 break;
9723 case SIR_IPV6_NS_OFFLOAD:
9724 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9725 pHostOffloadParams->params.hostIpv6Addr,
9726 16);
9727
9728#ifdef WLAN_NS_OFFLOAD
9729 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9730 {
9731 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9732 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9733 16);
9734 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9735 }
9736 else
9737 {
9738 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9739 }
9740
9741 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9742 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9743 16);
9744 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9745 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9746 6);
9747
9748 //Only two are supported so let's go through them without a loop
9749 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9750 {
9751 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9752 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9753 16);
9754 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9755 }
9756 else
9757 {
9758 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9759 }
9760
9761 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9762 {
9763 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9764 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9765 16);
9766 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9767 }
9768 else
9769 {
9770 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9771 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9772 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9773 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9774 break;
9775#endif //WLAN_NS_OFFLOAD
9776 default:
9777 {
9778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9779 "No Handling for Offload Type %x in WDA "
9780 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9781 //WDA_VOS_ASSERT(0) ;
9782 }
9783 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9784 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9785 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9786
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9787 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9788 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9789 /* store Params pass it to WDI */
9790 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9791 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9792
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9793
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9794 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9795 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9796
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9797 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9798 {
9799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9800 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9801 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9802 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9803 vos_mem_free(pWdaParams->wdaMsgParam);
9804 vos_mem_free(pWdaParams) ;
9805 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9806 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9807
9808}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9809/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9810 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9811 *
9812 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9813void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9814{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9815 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9816
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9818 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9819
9820 if(NULL == pWdaParams)
9821 {
9822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9823 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9824 VOS_ASSERT(0) ;
9825 return ;
9826 }
9827
9828 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9829 vos_mem_free(pWdaParams->wdaMsgParam);
9830 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9831
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9832 //print a msg, nothing else to do
9833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9834 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9835 return ;
9836}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9837/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9838 * FUNCTION: WDA_KeepAliveReqCallback
9839 * Free memory.
9840 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9841 */
9842void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9843{
9844 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9845
9846 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9847 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9848
9849 if(NULL == pWdaParams)
9850 {
9851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9852 "%s: pWdaParams received NULL", __func__);
9853 VOS_ASSERT(0);
9854 return;
9855 }
9856
9857 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9858 {
9859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9860 vos_mem_free(pWdaParams->wdaMsgParam);
9861 vos_mem_free(pWdaParams);
9862 }
9863
9864 return;
9865}
9866/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9867 * FUNCTION: WDA_ProcessKeepAliveReq
9868 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9869 * wakeup due to broadcast traffic (sta mode).
9870 */
9871VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9872 tSirKeepAliveReq *pKeepAliveParams)
9873{
9874 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9875 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9876 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9877 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9878 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9879 tWDA_ReqParams *pWdaParams;
9880
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9882 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9883 if(NULL == wdiKeepAliveInfo)
9884 {
9885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9886 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9887 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9888 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9889 return VOS_STATUS_E_NOMEM;
9890 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9891
9892 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9893 if(NULL == pWdaParams)
9894 {
9895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9896 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9897 VOS_ASSERT(0);
9898 vos_mem_free(wdiKeepAliveInfo);
9899 vos_mem_free(pKeepAliveParams);
9900 return VOS_STATUS_E_NOMEM;
9901 }
9902
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9903 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9904 pKeepAliveParams->packetType;
9905 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9906 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9907
9908 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9909 pKeepAliveParams->bssId,
9910 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9911
9912 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9913 {
9914 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9915 pKeepAliveParams->hostIpv4Addr,
9916 SIR_IPV4_ADDR_LEN);
9917 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9918 pKeepAliveParams->destIpv4Addr,
9919 SIR_IPV4_ADDR_LEN);
9920 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9921 pKeepAliveParams->destMacAddr,
9922 SIR_MAC_ADDR_LEN);
9923 }
9924 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9925 {
9926 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9927 SIR_IPV4_ADDR_LEN,
9928 0);
9929 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9930 SIR_IPV4_ADDR_LEN,
9931 0);
9932 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9933 SIR_MAC_ADDR_LEN,
9934 0);
9935 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9936 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9937 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9938
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9939 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9940 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9941 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9942 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9943 pWdaParams->pWdaContext = pWDA;
9944
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9946 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9947 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9948 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9949 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9951 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9952 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9953 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9954 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9956 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9957 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9958 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9959 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9960 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9961 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9962 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9964 "TimePeriod %d PacketType %d",
9965 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9966 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9967 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9968 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9969
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9970 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9971 {
9972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9973 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9974 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9975 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9976 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9977 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9978 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9979 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9980
9981}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9982/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9983 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9984 *
9985 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9986void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9987 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9988 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9989{
9990 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9992 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9993 if(NULL == pWdaParams)
9994 {
9995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9996 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9997 VOS_ASSERT(0) ;
9998 return ;
9999 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10000 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10001 vos_mem_free(pWdaParams->wdaMsgParam);
10002 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10003 return ;
10004}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10005/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10006 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
10007 * Free memory.
10008 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
10009 */
10010void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10011{
10012 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10013
10014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10015 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10016
10017 if(NULL == pWdaParams)
10018 {
10019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10020 "%s: pWdaParams received NULL", __func__);
10021 VOS_ASSERT(0);
10022 return;
10023 }
10024
10025 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10026 {
10027 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10028 vos_mem_free(pWdaParams->wdaMsgParam);
10029 vos_mem_free(pWdaParams);
10030 }
10031
10032 return;
10033}
10034
10035/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10036 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
10037 * Request to WDI to add WOWL Bcast pattern
10038 */
10039VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
10040 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
10041{
10042 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10043 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10044 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
10045 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
10046 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
10047 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10049 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10050 if(NULL == wdiWowlAddBcPtrnInfo)
10051 {
10052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10053 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10054 VOS_ASSERT(0);
10055 return VOS_STATUS_E_NOMEM;
10056 }
10057 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10058 if(NULL == pWdaParams)
10059 {
10060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10061 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10062 VOS_ASSERT(0);
10063 vos_mem_free(wdiWowlAddBcPtrnInfo);
10064 return VOS_STATUS_E_NOMEM;
10065 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10066 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
10067 pWowlAddBcPtrnParams->ucPatternId;
10068 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
10069 pWowlAddBcPtrnParams->ucPatternByteOffset;
10070 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
10071 pWowlAddBcPtrnParams->ucPatternMaskSize;
10072 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
10073 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10074 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
10075 {
10076 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10077 pWowlAddBcPtrnParams->ucPattern,
10078 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
10079 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10080 pWowlAddBcPtrnParams->ucPatternMask,
10081 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
10082 }
10083 else
10084 {
10085 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10086 pWowlAddBcPtrnParams->ucPattern,
10087 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10088 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10089 pWowlAddBcPtrnParams->ucPatternMask,
10090 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10091
10092 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
10093 pWowlAddBcPtrnParams->ucPatternExt,
10094 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10095 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
10096 pWowlAddBcPtrnParams->ucPatternMaskExt,
10097 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10098 }
10099
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10100 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
10101 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
10102
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10103 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
10104 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10105 /* Store param pointer as passed in by caller */
10106 /* store Params pass it to WDI */
10107 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
10108 pWdaParams->pWdaContext = pWDA;
10109 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10110 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10111 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10112 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10113 {
10114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10115 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10116 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10117 vos_mem_free(pWdaParams->wdaMsgParam) ;
10118 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10119 vos_mem_free(pWdaParams) ;
10120 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10121 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10122
10123}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10124/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10125 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10126 *
10127 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10128void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10129 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
10130 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10131{
10132 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10134 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10135 if(NULL == pWdaParams)
10136 {
10137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10138 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10139 VOS_ASSERT(0) ;
10140 return ;
10141 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10143 vos_mem_free(pWdaParams->wdaMsgParam);
10144 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10145 return ;
10146}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10147/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10148 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
10149 * Free memory.
10150 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
10151 */
10152void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10153{
10154 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10155
10156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10157 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10158
10159 if(NULL == pWdaParams)
10160 {
10161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10162 "%s: pWdaParams received NULL", __func__);
10163 VOS_ASSERT(0);
10164 return;
10165 }
10166
10167 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10168 {
10169 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10170 vos_mem_free(pWdaParams->wdaMsgParam);
10171 vos_mem_free(pWdaParams);
10172 }
10173
10174 return;
10175}
10176/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10177 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
10178 * Request to WDI to delete WOWL Bcast pattern
10179 */
10180VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
10181 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
10182{
10183 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10184 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10185 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
10186 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
10187 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
10188 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10190 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10191 if(NULL == wdiWowlDelBcPtrnInfo)
10192 {
10193 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10194 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10195 VOS_ASSERT(0);
10196 return VOS_STATUS_E_NOMEM;
10197 }
10198 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10199 if(NULL == pWdaParams)
10200 {
10201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10202 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10203 VOS_ASSERT(0);
10204 vos_mem_free(wdiWowlDelBcPtrnInfo);
10205 return VOS_STATUS_E_NOMEM;
10206 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10207 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
10208 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10209
10210 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
10211 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
10212
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10213 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
10214 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10215 /* Store param pointer as passed in by caller */
10216 /* store Params pass it to WDI */
10217 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
10218 pWdaParams->pWdaContext = pWDA;
10219 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10220 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10221 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10222 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10223 {
10224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10225 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10226 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10227 vos_mem_free(pWdaParams->wdaMsgParam) ;
10228 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10229 vos_mem_free(pWdaParams) ;
10230 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10231 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10232
10233}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10234/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10235 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10236 *
10237 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10238void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10239{
10240 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10241 tWDA_CbContext *pWDA;
10242 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10244 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10245 if(NULL == pWdaParams)
10246 {
10247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10248 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10249 VOS_ASSERT(0) ;
10250 return ;
10251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10252 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10253 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
10254
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10255 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
10256
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10257 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10258 vos_mem_free(pWdaParams) ;
10259
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10260 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10261 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10262 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10263 return ;
10264}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10265/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10266 * FUNCTION: WDA_WowlEnterReqCallback
10267 * Free memory and send WOWL Enter RSP back to PE.
10268 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
10269 */
10270void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
10271{
10272 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10273 tWDA_CbContext *pWDA;
10274 tSirHalWowlEnterParams *pWowlEnterParams;
10275
10276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10277 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10278
10279 if(NULL == pWdaParams)
10280 {
10281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10282 "%s: pWdaParams received NULL", __func__);
10283 VOS_ASSERT(0);
10284 return;
10285 }
10286
10287 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10288 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10289 pWowlEnterParams->status = wdiStatus;
10290
10291 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10292 {
10293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10294 vos_mem_free(pWdaParams);
10295 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10296 }
10297
10298 return;
10299}
10300/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10301 * FUNCTION: WDA_ProcessWowlEnterReq
10302 * Request to WDI to enter WOWL
10303 */
10304VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10305 tSirHalWowlEnterParams *pWowlEnterParams)
10306{
10307 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10308 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10309 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10310 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10311 sizeof(WDI_WowlEnterReqParamsType)) ;
10312 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10314 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10315 if(NULL == wdiWowlEnterInfo)
10316 {
10317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10318 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10319 VOS_ASSERT(0);
10320 return VOS_STATUS_E_NOMEM;
10321 }
10322 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10323 if(NULL == pWdaParams)
10324 {
10325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10326 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10327 VOS_ASSERT(0);
10328 vos_mem_free(wdiWowlEnterInfo);
10329 return VOS_STATUS_E_NOMEM;
10330 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10331
10332 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10333
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10334 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10335 pWowlEnterParams->magicPtrn,
10336 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10337 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10338 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10339 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10340 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10341 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10342 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10343 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10344 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10345 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10346 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10347 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10348 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10349 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10350 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10351 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10352 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10353#ifdef WLAN_WAKEUP_EVENTS
10354 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10355 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10356
10357 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10358 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10359
10360 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10361 pWowlEnterParams->ucWowNetScanOffloadMatch;
10362
10363 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10364 pWowlEnterParams->ucWowGTKRekeyError;
10365
10366 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10367 pWowlEnterParams->ucWoWBSSConnLoss;
10368#endif // WLAN_WAKEUP_EVENTS
10369
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10370 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10371 pWowlEnterParams->bssIdx;
10372
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10373 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10374 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10375 /* Store param pointer as passed in by caller */
10376 /* store Params pass it to WDI */
10377 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10378 pWdaParams->pWdaContext = pWDA;
10379 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10380 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10381 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10382 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10383 {
10384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10385 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10386 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10387 vos_mem_free(pWdaParams->wdaMsgParam) ;
10388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10389 vos_mem_free(pWdaParams) ;
10390 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10391 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10392
10393}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10394/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10395 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10396 *
10397 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10398void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10399{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10400 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10401 tWDA_CbContext *pWDA;
10402 tSirHalWowlExitParams *pWowlExitParams;
10403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10404 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10405 if(NULL == pWdaParams)
10406 {
10407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10408 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10409 VOS_ASSERT(0) ;
10410 return ;
10411 }
10412 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10413 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10414
10415 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10416 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10417
10418 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10419 vos_mem_free(pWdaParams) ;
10420
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10422 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10423 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10424 return ;
10425}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10426/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10427 * FUNCTION: WDA_WowlExitReqCallback
10428 * Free memory and send WOWL Exit RSP back to PE.
10429 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10430 */
10431void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10432{
10433 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10434 tWDA_CbContext *pWDA;
10435 tSirHalWowlExitParams *pWowlExitParams;
10436
10437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10438 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10439
10440 if(NULL == pWdaParams)
10441 {
10442 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10443 "%s: pWdaParams received NULL", __func__);
10444 VOS_ASSERT(0);
10445 return;
10446 }
10447
10448 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10449 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10450 pWowlExitParams->status = wdiStatus;
10451
10452 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10453 {
10454 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10455 vos_mem_free(pWdaParams);
10456 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10457 }
10458
10459 return;
10460}
10461/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10462 * FUNCTION: WDA_ProcessWowlExitReq
10463 * Request to WDI to add WOWL Bcast pattern
10464 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10465VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10466 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10467{
10468 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10469 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10470 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10471 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10472 sizeof(WDI_WowlExitReqParamsType)) ;
10473 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10475 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10476 if(NULL == wdiWowlExitInfo)
10477 {
10478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10479 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10480 VOS_ASSERT(0);
10481 return VOS_STATUS_E_NOMEM;
10482 }
10483 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10484 if(NULL == pWdaParams)
10485 {
10486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10487 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10488 VOS_ASSERT(0);
10489 vos_mem_free(wdiWowlExitInfo);
10490 return VOS_STATUS_E_NOMEM;
10491 }
10492
10493 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10494 pWowlExitParams->bssIdx;
10495
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10496 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10497 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10498
10499 /* Store param pointer as passed in by caller */
10500 /* store Params pass it to WDI */
10501 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10502 pWdaParams->pWdaContext = pWDA;
10503 pWdaParams->wdaMsgParam = pWowlExitParams;
10504
10505 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10506 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10507
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10508 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10509 {
10510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10511 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10512 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10513 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10514 vos_mem_free(pWdaParams->wdaMsgParam);
10515 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10516 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10517 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10518}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10519/*
10520 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10521 * Request to WDI to determine whether a given station is capable of
10522 * using HW-based frame translation
10523 */
10524v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10525 tANI_U8 staIdx)
10526{
10527 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10528}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10529
10530/*
10531 * FUNCTION: WDA_IsSelfSTA
10532 * Request to WDI to determine whether a given STAID is self station
10533 * index.
10534 */
10535v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10536{
10537
10538 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10539
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10540 if (NULL != pWDA)
10541 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10542 else
10543 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10544}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10545/*
10546 * FUNCTION: WDA_NvDownloadReqCallback
10547 * send NV Download RSP back to PE
10548 */
10549void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10550 void* pUserData)
10551{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10552
10553 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10554 tWDA_CbContext *pWDA;
10555
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10557 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10558
10559 if(NULL == pWdaParams)
10560 {
10561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10562 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10563 VOS_ASSERT(0) ;
10564 return ;
10565 }
10566
10567 pWDA = pWdaParams->pWdaContext;
10568
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10569 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10570 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10571 vos_mem_free(pWdaParams);
10572
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10573 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10574 return ;
10575}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10576/*
10577 * FUNCTION: WDA_ProcessNvDownloadReq
10578 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10579 */
10580VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10581{
10582 /* Initialize the local Variables*/
10583 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10584 v_VOID_t *pNvBuffer=NULL;
10585 v_SIZE_t bufferSize = 0;
10586 WDI_Status status = WDI_STATUS_E_FAILURE;
10587 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10588 tWDA_ReqParams *pWdaParams ;
10589
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10591 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10592 if(NULL == pWDA)
10593 {
10594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10595 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10596 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10597 return VOS_STATUS_E_FAILURE;
10598 }
10599
10600 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10601 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10602
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10603 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10604 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10605 if(NULL == wdiNvDownloadReqParam)
10606 {
10607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10608 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10609 VOS_ASSERT(0);
10610 return VOS_STATUS_E_NOMEM;
10611 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10612 /* Copy Params to wdiNvDownloadReqParam*/
10613 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10614 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10615
10616 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10617 if(NULL == pWdaParams)
10618 {
10619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10620 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10621 VOS_ASSERT(0);
10622 vos_mem_free(wdiNvDownloadReqParam);
10623 return VOS_STATUS_E_NOMEM;
10624 }
10625
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10626 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10627 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10628 pWdaParams->wdaMsgParam = NULL;
10629 pWdaParams->pWdaContext = pWDA;
10630
10631
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10632 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10633
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10634 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10635 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10636
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10637 if(IS_WDI_STATUS_FAILURE(status))
10638 {
10639 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10640 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10641 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10642 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10643 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10644 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10645}
10646/*
10647 * FUNCTION: WDA_FlushAcReqCallback
10648 * send Flush AC RSP back to TL
10649 */
10650void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10651{
10652 vos_msg_t wdaMsg = {0} ;
10653 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10654 tFlushACReq *pFlushACReqParams;
10655 tFlushACRsp *pFlushACRspParams;
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 == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10662 VOS_ASSERT(0) ;
10663 return ;
10664 }
10665
10666 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10667 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10668 if(NULL == pFlushACRspParams)
10669 {
10670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10671 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10672 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10673 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10674 return ;
10675 }
10676 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10677 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10678 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10679 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10680 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10681 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10682 vos_mem_free(pWdaParams->wdaMsgParam) ;
10683 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10684 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10685 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10686 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10687 // POST message to TL
10688 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10689
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10690 return ;
10691}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10692/*
10693 * FUNCTION: WDA_ProcessFlushAcReq
10694 * Request to WDI to Update the DELBA REQ params.
10695 */
10696VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10697 tFlushACReq *pFlushAcReqParams)
10698{
10699 WDI_Status status = WDI_STATUS_SUCCESS ;
10700 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10701 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10702 sizeof(WDI_FlushAcReqParamsType)) ;
10703 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10704 if(NULL == wdiFlushAcReqParam)
10705 {
10706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10707 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10708 VOS_ASSERT(0);
10709 return VOS_STATUS_E_NOMEM;
10710 }
10711 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10712 if(NULL == pWdaParams)
10713 {
10714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10715 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10716 VOS_ASSERT(0);
10717 vos_mem_free(wdiFlushAcReqParam);
10718 return VOS_STATUS_E_NOMEM;
10719 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10721 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10722 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10723 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10724 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10725 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10726 /* Store Flush AC pointer, as this will be used for response */
10727 /* store Params pass it to WDI */
10728 pWdaParams->pWdaContext = pWDA;
10729 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10730 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10731 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10732 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10733 if(IS_WDI_STATUS_FAILURE(status))
10734 {
10735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10736 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10737 vos_mem_free(pWdaParams->wdaMsgParam) ;
10738 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10739 vos_mem_free(pWdaParams) ;
10740 //TODO: respond to TL with failure
10741 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10742 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10743}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10744/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10745 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10746 *
10747 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10748void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10749{
10750 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10751 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10752 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10753
10754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10755 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10756 if(NULL == pWdaParams)
10757 {
10758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10759 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10760 VOS_ASSERT(0) ;
10761 return ;
10762 }
10763 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10764 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10765 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10766 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10767 {
10768 pWDA->wdaAmpSessionOn = VOS_FALSE;
10769 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10770 vos_mem_free(pWdaParams->wdaMsgParam) ;
10771 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10772 vos_mem_free(pWdaParams) ;
10773 /*
10774 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10775 * param here
10776 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10777 return ;
10778}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10779/*
10780 * FUNCTION: WDA_BtAmpEventReqCallback
10781 * Free memory.
10782 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10783 */
10784void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10785{
10786 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10787 tWDA_CbContext *pWDA;
10788 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10789
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10791 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10792
10793 if(NULL == pWdaParams)
10794 {
10795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10796 "%s: pWdaParams received NULL", __func__);
10797 VOS_ASSERT(0);
10798 return;
10799 }
10800
10801 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10802 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10803
10804 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10805 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10806 {
10807 pWDA->wdaAmpSessionOn = VOS_FALSE;
10808 }
10809
10810 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10811 {
10812 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10813 vos_mem_free(pWdaParams->wdaMsgParam);
10814 vos_mem_free(pWdaParams);
10815 }
10816
10817 return;
10818}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10819/*
10820 * FUNCTION: WDA_ProcessBtAmpEventReq
10821 * Request to WDI to Update with BT AMP events.
10822 */
10823VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10824 tSmeBtAmpEvent *pBtAmpEventParams)
10825{
10826 WDI_Status status = WDI_STATUS_SUCCESS ;
10827 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10828 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10829 sizeof(WDI_BtAmpEventParamsType)) ;
10830 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10831 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10832 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10833 if(NULL == wdiBtAmpEventParam)
10834 {
10835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10836 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10837 VOS_ASSERT(0);
10838 return VOS_STATUS_E_NOMEM;
10839 }
10840 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10841 if(NULL == pWdaParams)
10842 {
10843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10844 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10845 VOS_ASSERT(0);
10846 vos_mem_free(wdiBtAmpEventParam);
10847 return VOS_STATUS_E_NOMEM;
10848 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10849 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10850 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10851 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10852 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10853 /* Store BT AMP event pointer, as this will be used for response */
10854 /* store Params pass it to WDI */
10855 pWdaParams->pWdaContext = pWDA;
10856 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10857 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10858 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10859 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10860 if(IS_WDI_STATUS_FAILURE(status))
10861 {
10862 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10863 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10864 vos_mem_free(pWdaParams->wdaMsgParam) ;
10865 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10866 vos_mem_free(pWdaParams) ;
10867 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10868 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10869 {
10870 pWDA->wdaAmpSessionOn = VOS_TRUE;
10871 }
10872 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10873}
10874
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10875/*
10876 * FUNCTION: WDA_FTMCommandReqCallback
10877 * Handle FTM CMD response came from HAL
10878 * Route responce to HDD FTM
10879 */
10880void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10881 void *usrData)
10882{
10883 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10884 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10885 {
10886 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10887 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10888 return;
10889 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10890 /* Release Current FTM Command Request */
10891 vos_mem_free(pWDA->wdaFTMCmdReq);
10892 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10893 /* Post FTM Responce to HDD FTM */
10894 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10895 return;
10896}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10897/*
10898 * FUNCTION: WDA_ProcessFTMCommand
10899 * Send FTM command to WDI
10900 */
10901VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10902 tPttMsgbuffer *pPTTFtmCmd)
10903{
10904 WDI_Status status = WDI_STATUS_SUCCESS;
10905 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10906 ftmCMDReq = (WDI_FTMCommandReqType *)
10907 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10908 if(NULL == ftmCMDReq)
10909 {
10910 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10911 "WDA FTM Command buffer alloc fail");
10912 return VOS_STATUS_E_NOMEM;
10913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10914 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10915 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10916 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10917 /* Send command to WDI */
10918 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10919 return status;
10920}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10921#ifdef FEATURE_OEM_DATA_SUPPORT
10922/*
10923 * FUNCTION: WDA_StartOemDataReqCallback
10924 *
10925 */
10926void WDA_StartOemDataReqCallback(
10927 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10928 void* pUserData)
10929{
10930 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10931 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10932 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10933 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10934
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10936 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10937
10938 if(NULL == pWdaParams)
10939 {
10940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10941 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10942 VOS_ASSERT(0) ;
10943 return ;
10944 }
10945 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10946
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10947 if(NULL == pWDA)
10948 {
10949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10950 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10951 VOS_ASSERT(0);
10952 return ;
10953 }
10954
10955 /*
10956 * Allocate memory for response params sent to PE
10957 */
10958 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10959
10960 // Check if memory is allocated for OemdataMeasRsp Params.
10961 if(NULL == pOemDataRspParams)
10962 {
10963 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10964 "OEM DATA WDA callback alloc fail");
10965 VOS_ASSERT(0) ;
10966 return;
10967 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10968
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10969 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10971 vos_mem_free(pWdaParams->wdaMsgParam);
10972 vos_mem_free(pWdaParams) ;
10973
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10974 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10975 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10976 * Also, here success always means that we have atleast one BSSID.
10977 */
10978 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10979
10980 //enable Tx
10981 status = WDA_ResumeDataTx(pWDA);
10982 if(status != VOS_STATUS_SUCCESS)
10983 {
10984 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10985 }
10986 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10987 return ;
10988}
10989/*
10990 * FUNCTION: WDA_ProcessStartOemDataReq
10991 * Send Start Oem Data Req to WDI
10992 */
10993VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10994 tStartOemDataReq *pOemDataReqParams)
10995{
10996 WDI_Status status = WDI_STATUS_SUCCESS;
10997 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10998 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10999
11000 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
11001
11002 if(NULL == wdiOemDataReqParams)
11003 {
11004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11005 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11006 VOS_ASSERT(0);
11007 return VOS_STATUS_E_NOMEM;
11008 }
11009
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11010 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
11011 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
11012 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
11013 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11014
11015 wdiOemDataReqParams->wdiReqStatusCB = NULL;
11016
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11017 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11018 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11019 {
11020 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11021 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11022 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11023 vos_mem_free(pOemDataReqParams);
11024 VOS_ASSERT(0);
11025 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11026 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11027
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]11028 pWdaParams->pWdaContext = (void*)pWDA;
11029 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
11030 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11031
11032 status = WDI_StartOemDataReq(wdiOemDataReqParams,
11033 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11034
11035 if(IS_WDI_STATUS_FAILURE(status))
11036 {
11037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11038 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11039 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11040 vos_mem_free(pWdaParams->wdaMsgParam);
11041 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11042 }
11043 return CONVERT_WDI2VOS_STATUS(status) ;
11044}
11045#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11046/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11047 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11048 *
11049 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11050void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11051{
11052 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11054 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11055 if(NULL == pWdaParams)
11056 {
11057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11058 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11059 VOS_ASSERT(0) ;
11060 return ;
11061 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11062
11063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11064 vos_mem_free(pWdaParams->wdaMsgParam);
11065 vos_mem_free(pWdaParams);
11066
11067 return ;
11068}
11069/*
11070 * FUNCTION: WDA_SetTxPerTrackingReqCallback
11071 * Free memory.
11072 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
11073 */
11074void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
11075{
11076 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11077
11078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11079 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11080
11081 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11082 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11084 "%s: pWdaParams received NULL", __func__);
11085 VOS_ASSERT(0);
11086 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11087 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11088
11089 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11090 {
11091 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11092 vos_mem_free(pWdaParams->wdaMsgParam);
11093 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11094 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11095
11096 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11097}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11098#ifdef WLAN_FEATURE_GTK_OFFLOAD
11099/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11100 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11101 *
11102 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11103void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11104 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11105{
11106 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11107
11108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11109 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11110 if(NULL == pWdaParams)
11111 {
11112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11113 "%s: pWdaParams received NULL", __func__);
11114 VOS_ASSERT(0);
11115 return;
11116 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11117
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11118 vos_mem_free(pWdaParams->wdaMsgParam) ;
11119 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11120 vos_mem_free(pWdaParams) ;
11121
11122 //print a msg, nothing else to do
11123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11124 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11125
11126 return ;
11127}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11128/*
11129 * FUNCTION: WDA_GTKOffloadReqCallback
11130 * Free memory.
11131 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
11132 */
11133void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11134{
11135 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11136
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11138 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11139
11140 if(NULL == pWdaParams)
11141 {
11142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11143 "%s: pWdaParams received NULL", __func__);
11144 VOS_ASSERT(0);
11145 return;
11146 }
11147
11148 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11149 {
11150 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11151 vos_mem_free(pWdaParams->wdaMsgParam);
11152 vos_mem_free(pWdaParams);
11153 }
11154
11155 return;
11156}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11157/*
11158 * FUNCTION: WDA_ProcessGTKOffloadReq
11159 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11160 * to broadcast traffic (sta mode).
11161 */
11162VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
11163 tpSirGtkOffloadParams pGtkOffloadParams)
11164{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11165 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11166 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
11167 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
11168 sizeof(WDI_GtkOffloadReqMsg)) ;
11169 tWDA_ReqParams *pWdaParams ;
11170
11171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11172 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11173
11174 if(NULL == wdiGtkOffloadReqMsg)
11175 {
11176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11177 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11178 VOS_ASSERT(0);
11179 return VOS_STATUS_E_NOMEM;
11180 }
11181
11182 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11183 if(NULL == pWdaParams)
11184 {
11185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11186 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11187 VOS_ASSERT(0);
11188 vos_mem_free(wdiGtkOffloadReqMsg);
11189 return VOS_STATUS_E_NOMEM;
11190 }
11191
11192 //
11193 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
11194 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11195
11196 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11197 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11198
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11199 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
11200 // Copy KCK
11201 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
11202 // Copy KEK
11203 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
11204 // Copy KeyReplayCounter
11205 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
11206 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
11207
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11208 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
11209 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11210
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11211
11212 /* Store Params pass it to WDI */
11213 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
11214 pWdaParams->pWdaContext = pWDA;
11215 /* Store param pointer as passed in by caller */
11216 pWdaParams->wdaMsgParam = pGtkOffloadParams;
11217
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11218 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11219
11220 if(IS_WDI_STATUS_FAILURE(status))
11221 {
11222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11223 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
11224 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11225 vos_mem_free(pWdaParams->wdaMsgParam);
11226 vos_mem_free(pWdaParams);
11227 }
11228
11229 return CONVERT_WDI2VOS_STATUS(status) ;
11230}
11231
11232/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11233 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11234 *
11235 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11236void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11237 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11238{
11239 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11240 tWDA_CbContext *pWDA;
11241 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11242 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11243 vos_msg_t vosMsg;
11244
11245 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11246 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11247
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11248 if(NULL == pWdaParams)
11249 {
11250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11251 "%s: pWdaParams received NULL", __func__);
11252 VOS_ASSERT(0);
11253 return;
11254 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11255
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11256 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
11257 if(NULL == pGtkOffloadGetInfoRsp)
11258 {
11259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11260 "%s: vos_mem_malloc failed ", __func__);
11261 VOS_ASSERT(0);
11262 return;
11263 }
11264
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11265 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
11266 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
11267
11268 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
11269 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
11270
11271 /* Message Header */
11272 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]11273 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11274
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11275 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
11276 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
11277 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
11278 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
11279 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11280
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11281 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11282 pwdiGtkOffloadGetInfoRsparams->bssId,
11283 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11284 /* VOS message wrapper */
11285 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11286 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11287 vosMsg.bodyval = 0;
11288
11289 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11290 {
11291 /* free the mem and return */
11292 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11293 }
11294
11295 vos_mem_free(pWdaParams->wdaMsgParam) ;
11296 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11297 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11298
11299 return;
11300}
11301/*
11302 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11303 * Free memory and send RSP back to SME.
11304 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11305 */
11306void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11307{
11308 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11309 vos_msg_t vosMsg;
11310
11311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11312 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11313
11314 if(NULL == pWdaParams)
11315 {
11316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11317 "%s: pWdaParams received NULL", __func__);
11318 VOS_ASSERT(0);
11319 return;
11320 }
11321
11322 /* VOS message wrapper */
11323 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11324 vosMsg.bodyptr = NULL;
11325 vosMsg.bodyval = 0;
11326
11327 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11328 {
11329 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11330 vos_mem_free(pWdaParams->wdaMsgParam);
11331 vos_mem_free(pWdaParams);
11332 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11333 }
11334
11335 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11336}
11337#endif
11338
11339/*
11340 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11341 * Request to WDI to set Tx Per Tracking configurations
11342 */
11343VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11344{
11345 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11346 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11347 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11348 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11349 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11350 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11351 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11352 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11353 if(NULL == pwdiSetTxPerTrackingReqParams)
11354 {
11355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11356 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11357 vos_mem_free(pTxPerTrackingParams);
11358 VOS_ASSERT(0);
11359 return VOS_STATUS_E_NOMEM;
11360 }
11361 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11362 if(NULL == pWdaParams)
11363 {
11364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11365 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11366 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11367 vos_mem_free(pTxPerTrackingParams);
11368 VOS_ASSERT(0);
11369 return VOS_STATUS_E_NOMEM;
11370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11371 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11372 pTxPerTrackingParams->ucTxPerTrackingEnable;
11373 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11374 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11375 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11376 pTxPerTrackingParams->ucTxPerTrackingRatio;
11377 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11378 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11379 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11380 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11381 /* Store param pointer as passed in by caller */
11382 /* store Params pass it to WDI
11383 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11384 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11385 pWdaParams->pWdaContext = pWDA;
11386 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11387 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11388 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11389 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11390 {
11391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11392 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11393 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11394 vos_mem_free(pWdaParams->wdaMsgParam) ;
11395 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11396 vos_mem_free(pWdaParams) ;
11397 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11398 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11399
11400}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11401/*
11402 * FUNCTION: WDA_HALDumpCmdCallback
11403 * Send the VOS complete .
11404 */
11405void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11406 void* pUserData)
11407{
11408 tANI_U8 *buffer = NULL;
11409 tWDA_CbContext *pWDA = NULL;
11410 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11411 if(NULL == pWdaParams)
11412 {
11413 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11414 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11415 VOS_ASSERT(0) ;
11416 return ;
11417 }
11418
11419 pWDA = pWdaParams->pWdaContext;
11420 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11421 if(wdiRspParams->usBufferLen > 0)
11422 {
11423 /*Copy the Resp data to UMAC supplied buffer*/
11424 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11425 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11426 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11427 vos_mem_free(pWdaParams);
11428
11429 /* Indicate VOSS about the start complete */
11430 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11431 return ;
11432}
11433
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11434/*
11435 * FUNCTION: WDA_ProcessHALDumpCmdReq
11436 * Send Dump command to WDI
11437 */
11438VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11439 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11440 tANI_U32 arg4, tANI_U8 *pBuffer)
11441{
11442 WDI_Status status = WDI_STATUS_SUCCESS;
11443 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11444 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11445 tWDA_ReqParams *pWdaParams ;
11446 pVosContextType pVosContext = NULL;
11447 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11448 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11449 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11450 if(pVosContext)
11451 {
11452 if (pVosContext->isLogpInProgress)
11453 {
11454 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11455 "%s:LOGP in Progress. Ignore!!!", __func__);
11456 return VOS_STATUS_E_BUSY;
11457 }
11458 }
11459 else
11460 {
11461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11462 "%s: VOS Context Null", __func__);
11463 return VOS_STATUS_E_RESOURCES;
11464 }
11465
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11466 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11467 if(NULL == pWdaParams)
11468 {
11469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11470 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11471 return VOS_STATUS_E_NOMEM;
11472 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11473 /* Allocate memory WDI request structure*/
11474 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11475 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11476 if(NULL == wdiHALDumpCmdReqParam)
11477 {
11478 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11479 "WDA HAL DUMP Command buffer alloc fail");
11480 vos_mem_free(pWdaParams);
11481 return WDI_STATUS_E_FAILURE;
11482 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11483 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11484 /* Extract the arguments */
11485 wdiHalDumpCmdInfo->command = cmd;
11486 wdiHalDumpCmdInfo->argument1 = arg1;
11487 wdiHalDumpCmdInfo->argument2 = arg2;
11488 wdiHalDumpCmdInfo->argument3 = arg3;
11489 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11490 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11491 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11492
11493 /* Response message will be passed through the buffer */
11494 pWdaParams->wdaMsgParam = (void *)pBuffer;
11495
11496 /* store Params pass it to WDI */
11497 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11498 /* Send command to WDI */
11499 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11500 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11501 if ( vStatus != VOS_STATUS_SUCCESS )
11502 {
11503 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11504 {
11505 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11506 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11507 }
11508 else
11509 {
11510 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11511 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11512 }
11513 VOS_ASSERT(0);
11514 }
11515 return status;
11516}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11517#ifdef WLAN_FEATURE_GTK_OFFLOAD
11518/*
11519 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11520 * Request to WDI to get GTK Offload Information
11521 */
11522VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11523 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11524{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11525 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11526 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11527 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11528 tWDA_ReqParams *pWdaParams ;
11529
11530 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11531 {
11532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11533 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11534 VOS_ASSERT(0);
11535 return VOS_STATUS_E_NOMEM;
11536 }
11537
11538 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11539 if(NULL == pWdaParams)
11540 {
11541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11542 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11543 VOS_ASSERT(0);
11544 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11545 return VOS_STATUS_E_NOMEM;
11546 }
11547
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11548 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11549 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11550
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11551 /* Store Params pass it to WDI */
11552 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11553 pWdaParams->pWdaContext = pWDA;
11554 /* Store param pointer as passed in by caller */
11555 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11556
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11557 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11558 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11559
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11560 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11561
11562 if(IS_WDI_STATUS_FAILURE(status))
11563 {
11564 /* failure returned by WDI API */
11565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11566 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11567 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11568 vos_mem_free(pWdaParams) ;
11569 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11570 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11571 }
11572
11573 return CONVERT_WDI2VOS_STATUS(status) ;
11574}
11575#endif // WLAN_FEATURE_GTK_OFFLOAD
11576
11577/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11578 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11579 *
11580 */
11581VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11582 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11583{
11584 WDI_Status wdiStatus;
11585 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11586
11587 addPeriodicTxPtrnParams =
11588 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11589
11590 if (NULL == addPeriodicTxPtrnParams)
11591 {
11592 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11593 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11594 __func__);
11595
11596 return VOS_STATUS_E_NOMEM;
11597 }
11598
11599 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11600 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11601
11602 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11603 addPeriodicTxPtrnParams->pUserData = pWDA;
11604
11605 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11606
11607 if (WDI_STATUS_PENDING == wdiStatus)
11608 {
11609 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11610 "Pending received for %s:%d", __func__, __LINE__ );
11611 }
11612 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11613 {
11614 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11615 "Failure in %s:%d", __func__, __LINE__ );
11616 }
11617
11618 vos_mem_free(addPeriodicTxPtrnParams);
11619
11620 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11621}
11622
11623/*
11624 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11625 *
11626 */
11627VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11628 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11629{
11630 WDI_Status wdiStatus;
11631 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11632
11633 delPeriodicTxPtrnParams =
11634 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11635
11636 if (NULL == delPeriodicTxPtrnParams)
11637 {
11638 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11639 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11640 __func__);
11641
11642 return VOS_STATUS_E_NOMEM;
11643 }
11644
11645 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11646 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11647
11648 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11649 delPeriodicTxPtrnParams->pUserData = pWDA;
11650
11651 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11652
11653 if (WDI_STATUS_PENDING == wdiStatus)
11654 {
11655 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11656 "Pending received for %s:%d", __func__, __LINE__ );
11657 }
11658 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11659 {
11660 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11661 "Failure in %s:%d", __func__, __LINE__ );
11662 }
11663
11664 vos_mem_free(delPeriodicTxPtrnParams);
11665
11666 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11667}
11668
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11669#ifdef FEATURE_WLAN_BATCH_SCAN
11670/*
11671 * FUNCTION: WDA_ProcessStopBatchScanInd
11672 *
11673 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11674 *
11675 * PARAM:
11676 * pWDA: pointer to WDA context
11677 * pReq: pointer to stop batch scan request
11678 */
11679VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11680 tSirStopBatchScanInd *pReq)
11681{
11682 WDI_Status wdiStatus;
11683 WDI_StopBatchScanIndType wdiReq;
11684
11685 wdiReq.param = pReq->param;
11686
11687 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11688
11689 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11690 {
11691 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11692 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11693 }
11694
11695 vos_mem_free(pReq);
11696
11697 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11698}
11699/*==========================================================================
11700 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11701
11702 DESCRIPTION
11703 API to pull batch scan result from FW
11704
11705 PARAMETERS
11706 pWDA: Pointer to WDA context
11707 pGetBatchScanReq: Pointer to get batch scan result indication
11708
11709 RETURN VALUE
11710 NONE
11711
11712===========================================================================*/
11713VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11714 tSirTriggerBatchScanResultInd *pReq)
11715{
11716 WDI_Status wdiStatus;
11717 WDI_TriggerBatchScanResultIndType wdiReq;
11718
11719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11720 "------> %s " ,__func__);
11721
11722 wdiReq.param = pReq->param;
11723
11724 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11725
11726 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11727 {
11728 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11729 "Trigger batch scan result ind failed %s:%d",
11730 __func__, wdiStatus);
11731 }
11732
11733 vos_mem_free(pReq);
11734
11735 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11736}
11737
11738/*==========================================================================
11739 FUNCTION WDA_SetBatchScanRespCallback
11740
11741 DESCRIPTION
11742 API to process set batch scan response from FW
11743
11744 PARAMETERS
11745 pRsp: Pointer to set batch scan response
11746 pUserData: Pointer to user data
11747
11748 RETURN VALUE
11749 NONE
11750
11751===========================================================================*/
11752void WDA_SetBatchScanRespCallback
11753(
11754 WDI_SetBatchScanRspType *pRsp,
11755 void* pUserData
11756)
11757{
11758 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11759 tpAniSirGlobal pMac;
11760 void *pCallbackContext;
11761 tWDA_CbContext *pWDA = NULL ;
11762 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11763
11764
11765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11766 "<------ %s " ,__func__);
11767 if (NULL == pWdaParams)
11768 {
11769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11770 "%s: pWdaParams received NULL", __func__);
11771 VOS_ASSERT(0) ;
11772 return ;
11773 }
11774
11775 /*extract WDA context*/
11776 pWDA = pWdaParams->pWdaContext;
11777 if (NULL == pWDA)
11778 {
11779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11780 "%s:pWDA is NULL can't invole HDD callback",
11781 __func__);
11782 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11783 vos_mem_free(pWdaParams->wdaMsgParam);
11784 vos_mem_free(pWdaParams);
11785 VOS_ASSERT(0);
11786 return;
11787 }
11788
11789 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11790 vos_mem_free(pWdaParams->wdaMsgParam);
11791 vos_mem_free(pWdaParams);
11792
11793 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11794 if (NULL == pMac)
11795 {
11796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11797 "%s:pMac is NULL", __func__);
11798 VOS_ASSERT(0);
11799 return;
11800 }
11801
11802 pHddSetBatchScanRsp =
11803 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11804 if (NULL == pHddSetBatchScanRsp)
11805 {
11806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11807 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11808 VOS_ASSERT(0);
11809 return;
11810 }
11811
11812 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11813
11814 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11815 /*call hdd callback with set batch scan response data*/
11816 if(pMac->pmc.setBatchScanReqCallback)
11817 {
11818 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11819 }
11820 else
11821 {
11822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11823 "%s:HDD callback is null", __func__);
11824 VOS_ASSERT(0);
11825 }
11826
11827 vos_mem_free(pHddSetBatchScanRsp);
11828 return ;
11829}
11830
11831/*==========================================================================
11832 FUNCTION WDA_ProcessSetBatchScanReq
11833
11834 DESCRIPTION
11835 API to send set batch scan request to WDI
11836
11837 PARAMETERS
11838 pWDA: Pointer to WDA context
11839 pSetBatchScanReq: Pointer to set batch scan req
11840
11841 RETURN VALUE
11842 NONE
11843
11844===========================================================================*/
11845VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11846 tSirSetBatchScanReq *pSetBatchScanReq)
11847{
11848 WDI_Status status;
11849 tWDA_ReqParams *pWdaParams ;
11850 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11851
11852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11853 "------> %s " ,__func__);
11854
11855 pWdiSetBatchScanReq =
11856 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11857 if (NULL == pWdiSetBatchScanReq)
11858 {
11859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11860 "%s: VOS MEM Alloc Failure", __func__);
11861 vos_mem_free(pSetBatchScanReq);
11862 VOS_ASSERT(0);
11863 return VOS_STATUS_E_NOMEM;
11864 }
11865
11866 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11867 if (NULL == pWdaParams)
11868 {
11869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11870 "%s: VOS MEM Alloc Failure", __func__);
11871 VOS_ASSERT(0);
11872 vos_mem_free(pSetBatchScanReq);
11873 vos_mem_free(pWdiSetBatchScanReq);
11874 return VOS_STATUS_E_NOMEM;
11875 }
11876
11877 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11878 pWdiSetBatchScanReq->numberOfScansToBatch =
11879 pSetBatchScanReq->numberOfScansToBatch;
11880 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11881 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11882 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11883
11884 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11885 pWdaParams->pWdaContext = pWDA;
11886 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11887
11888 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11889 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11890 if (IS_WDI_STATUS_FAILURE(status))
11891 {
11892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11893 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11894 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11895 vos_mem_free(pWdaParams->wdaMsgParam);
11896 vos_mem_free(pWdaParams);
11897 }
11898 return CONVERT_WDI2VOS_STATUS(status);
11899}
11900
11901#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11902/*
11903 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11904 *
11905 * DESCRIPTION: This function sends start/update OBSS scan
11906 * inidcation message to WDI
11907 *
11908 * PARAM:
11909 * pWDA: pointer to WDA context
11910 * pReq: pointer to start OBSS scan request
11911 */
11912VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11913 tSirHT40OBSSScanInd *pReq)
11914{
11915 WDI_Status status;
11916 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11917 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11918
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11920 "------> %s " ,__func__);
11921 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11922 wdiOBSSScanParams.pUserData = pWDA;
11923
11924 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11925 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11926 pWdiOBSSScanInd->scanType = pReq->scanType;
11927 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11928 pReq->OBSSScanActiveDwellTime;
11929 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11930 pReq->OBSSScanPassiveDwellTime;
11931 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11932 pReq->BSSChannelWidthTriggerScanInterval;
11933 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11934 pReq->BSSWidthChannelTransitionDelayFactor;
11935 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11936 pReq->OBSSScanActiveTotalPerChannel;
11937 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11938 pReq->OBSSScanPassiveTotalPerChannel;
11939 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11940 pReq->OBSSScanActivityThreshold;
11941 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11942 vos_mem_copy(pWdiOBSSScanInd->channels,
11943 pReq->channels,
11944 pReq->channelCount);
11945 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11946 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11947 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11948 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11949 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11950
11951 vos_mem_copy(pWdiOBSSScanInd->ieField,
11952 pReq->ieField,
11953 pReq->ieFieldLen);
11954
11955 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11956 if (WDI_STATUS_PENDING == status)
11957 {
11958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11959 "Pending received for %s:%d ",__func__,__LINE__ );
11960 }
11961 else if (WDI_STATUS_SUCCESS_SYNC != status)
11962 {
11963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11964 "Failure in %s:%d ",__func__,__LINE__ );
11965 }
11966 return CONVERT_WDI2VOS_STATUS(status) ;
11967}
11968/*
11969 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11970 *
11971 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11972 *
11973 * PARAM:
11974 * pWDA: pointer to WDA context
11975 * pReq: pointer to stop batch scan request
11976 */
11977VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11978 tANI_U8 *bssIdx)
11979{
11980 WDI_Status status;
11981
11982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11983 "------> %s " ,__func__);
11984
11985 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11986 if (WDI_STATUS_PENDING == status)
11987 {
11988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11989 "Pending received for %s:%d ",__func__,__LINE__ );
11990 }
11991 else if (WDI_STATUS_SUCCESS_SYNC != status)
11992 {
11993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11994 "Failure in %s:%d ",__func__,__LINE__ );
11995 }
11996 return CONVERT_WDI2VOS_STATUS(status) ;
11997}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11998/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11999 * FUNCTION: WDA_ProcessRateUpdateInd
12000 *
12001 */
12002VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
12003 tSirRateUpdateInd *pRateUpdateParams)
12004{
12005 WDI_Status wdiStatus;
12006 WDI_RateUpdateIndParams rateUpdateParams;
12007
12008 vos_mem_copy(rateUpdateParams.bssid,
12009 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
12010
12011 rateUpdateParams.ucastDataRateTxFlag =
12012 pRateUpdateParams->ucastDataRateTxFlag;
12013 rateUpdateParams.reliableMcastDataRateTxFlag =
12014 pRateUpdateParams->reliableMcastDataRateTxFlag;
12015 rateUpdateParams.mcastDataRate24GHzTxFlag =
12016 pRateUpdateParams->mcastDataRate24GHzTxFlag;
12017 rateUpdateParams.mcastDataRate5GHzTxFlag =
12018 pRateUpdateParams->mcastDataRate5GHzTxFlag;
12019
12020 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
12021 rateUpdateParams.reliableMcastDataRate =
12022 pRateUpdateParams->reliableMcastDataRate;
12023 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
12024 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
12025
12026 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
12027 rateUpdateParams.pUserData = pWDA;
12028
12029 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
12030
12031 if (WDI_STATUS_PENDING == wdiStatus)
12032 {
12033 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12034 "Pending received for %s:%d", __func__, __LINE__ );
12035 }
12036 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
12037 {
12038 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12039 "Failure in %s:%d", __func__, __LINE__ );
12040 }
12041
12042 vos_mem_free(pRateUpdateParams);
12043
12044 return CONVERT_WDI2VOS_STATUS(wdiStatus);
12045}
12046
12047/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12048 * -------------------------------------------------------------------------
12049 * DATA interface with WDI for Mgmt Frames
12050 * -------------------------------------------------------------------------
12051 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12052/*
12053 * FUNCTION: WDA_TxComplete
12054 * Callback function for the WDA_TxPacket
12055 */
12056VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
12057 VOS_STATUS status )
12058{
12059
12060 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12061 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12062 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12063
12064 if(NULL == wdaContext)
12065 {
12066 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12067 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12068 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12069 VOS_ASSERT(0);
12070 return VOS_STATUS_E_FAILURE;
12071 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12072
12073 /*Check if frame was timed out or not*/
12074 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
12075 (v_PVOID_t)&uUserData);
12076
12077 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
12078 {
12079 /*Discard frame - no further processing is needed*/
12080 vos_pkt_return_packet(pData);
12081 return VOS_STATUS_SUCCESS;
12082 }
12083
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12084 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
12085 if( NULL!=wdaContext->pTxCbFunc)
12086 {
12087 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12088 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]12089 {
12090 wdaContext->pTxCbFunc(pMac, pData);
12091 }
12092 else
12093 {
12094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12095 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12096 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12097 //Return from here since we reaching here because the packet already timeout
12098 return status;
12099 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12100 }
12101
12102 /*
12103 * Trigger the event to bring the HAL TL Tx complete function to come
12104 * out of wait
12105 * Let the coe above to complete the packet first. When this event is set,
12106 * the thread waiting for the event may run and set Vospacket_freed causing the original
12107 * packet not being freed.
12108 */
12109 status = vos_event_set(&wdaContext->txFrameEvent);
12110 if(!VOS_IS_STATUS_SUCCESS(status))
12111 {
12112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12113 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12114 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12115 return status;
12116}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12117/*
12118 * FUNCTION: WDA_TxPacket
12119 * Forward TX management frame to WDI
12120 */
12121VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
12122 void *pFrmBuf,
12123 tANI_U16 frmLen,
12124 eFrameType frmType,
12125 eFrameTxDir txDir,
12126 tANI_U8 tid,
12127 pWDATxRxCompFunc pCompFunc,
12128 void *pData,
12129 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]12130 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12131{
12132 VOS_STATUS status = VOS_STATUS_SUCCESS ;
12133 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
12134 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
12135 tANI_U8 eventIdx = 0;
12136 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
12137 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12138 if((NULL == pWDA)||(NULL == pFrmBuf))
12139 {
12140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12141 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12142 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12143 VOS_ASSERT(0);
12144 return VOS_STATUS_E_FAILURE;
12145 }
12146
12147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12148 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12149 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
12150 if(NULL == pMac)
12151 {
12152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12153 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12154 VOS_ASSERT(0);
12155 return VOS_STATUS_E_FAILURE;
12156 }
12157
12158
12159
12160 /* store the call back function in WDA context */
12161 pWDA->pTxCbFunc = pCompFunc;
12162 /* store the call back for the function of ackTxComplete */
12163 if( pAckTxComp )
12164 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12165 if( NULL != pWDA->pAckTxCbFunc )
12166 {
12167 /* Already TxComp is active no need to active again */
12168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12169 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12170 pWDA->pAckTxCbFunc( pMac, 0);
12171 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12172
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12173 if( VOS_STATUS_SUCCESS !=
12174 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12175 {
12176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12177 "Tx Complete timeout Timer Stop Failed ");
12178 }
12179 else
12180 {
12181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12182 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12183 }
12184 }
12185
12186 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
12187 pWDA->pAckTxCbFunc = pAckTxComp;
12188 if( VOS_STATUS_SUCCESS !=
12189 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
12190 {
12191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12192 "Tx Complete Timer Start Failed ");
12193 pWDA->pAckTxCbFunc = NULL;
12194 return eHAL_STATUS_FAILURE;
12195 }
12196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12197 /* Reset the event to be not signalled */
12198 status = vos_event_reset(&pWDA->txFrameEvent);
12199 if(!VOS_IS_STATUS_SUCCESS(status))
12200 {
12201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12202 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12203 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
12204 if( pAckTxComp )
12205 {
12206 pWDA->pAckTxCbFunc = NULL;
12207 if( VOS_STATUS_SUCCESS !=
12208 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12209 {
12210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12211 "Tx Complete timeout Timer Stop Failed ");
12212 }
12213 }
12214 return VOS_STATUS_E_FAILURE;
12215 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12216
12217 /* If Peer Sta mask is set don't overwrite to self sta */
12218 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12219 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12220 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12221 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12222 else
12223 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12224 /* Get system role, use the self station if in unknown role or STA role */
12225 systemRole = wdaGetGlobalSystemRole(pMac);
12226 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
12227 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12228#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12229 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12230#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12231 ))
12232 {
12233 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
12234 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]12235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12236
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12237 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
12238 disassoc frame reaches the HW, HAL has already deleted the peer station */
12239 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12240 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]12241 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12242 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12243 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12244 /*Send Probe request frames on self sta idx*/
12245 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12246 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12247 /* Since we donot want probe responses to be retried, send probe responses
12248 through the NO_ACK queues */
12249 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
12250 {
12251 //probe response is sent out using self station and no retries options.
12252 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
12253 }
12254 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
12255 {
12256 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
12257 }
12258 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12259 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]12260
12261 /*Set frame tag to 0
12262 We will use the WDA user data in order to tag a frame as expired*/
12263 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12264 (v_PVOID_t)0);
12265
12266
12267 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
12268 frmLen, ucTypeSubType, tid,
12269 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
12270 {
12271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12272 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12273 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12274 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]12275 if( pAckTxComp )
12276 {
12277 pWDA->pAckTxCbFunc = NULL;
12278 if( VOS_STATUS_SUCCESS !=
12279 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12280 {
12281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12282 "Tx Complete timeout Timer Stop Failed ");
12283 }
12284 }
12285 return VOS_STATUS_E_FAILURE;
12286 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12287 /*
12288 * Wait for the event to be set by the TL, to get the response of TX
12289 * complete, this event should be set by the Callback function called by TL
12290 */
12291 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12292 &eventIdx);
12293 if(!VOS_IS_STATUS_SUCCESS(status))
12294 {
12295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12296 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12297 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12298 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12299 after the packet gets completed(packet freed once)*/
12300
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12301 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame]12302 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12303
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12304 /*Tag Frame as timed out for later deletion*/
12305 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12306 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12308 /* check whether the packet was freed already,so need not free again when
12309 * TL calls the WDA_Txcomplete routine
12310 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12311 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12312 /*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]12313 {
12314 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12315 } */
12316
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12317 if( pAckTxComp )
12318 {
12319 pWDA->pAckTxCbFunc = NULL;
12320 if( VOS_STATUS_SUCCESS !=
12321 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12322 {
12323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12324 "Tx Complete timeout Timer Stop Failed ");
12325 }
12326 }
12327 status = VOS_STATUS_E_FAILURE;
12328 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12329#ifdef WLAN_DUMP_MGMTFRAMES
12330 if (VOS_IS_STATUS_SUCCESS(status))
12331 {
12332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12333 "%s() TX packet : SubType %d", __func__,pFc->subType);
12334 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12335 pData, frmLen);
12336 }
12337#endif
12338
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12339 if (VOS_IS_STATUS_SUCCESS(status))
12340 {
12341 if (pMac->fEnableDebugLog & 0x1)
12342 {
12343 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12344 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12345 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12346 {
12347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12348 pFc->type, pFc->subType);
12349 }
12350 }
12351 }
12352
12353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12354 return status;
12355}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12356/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12357 * FUNCTION: WDA_ProcessDHCPStartInd
12358 * Forward DHCP Start to WDI
12359 */
12360static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12361 tAniDHCPInd *dhcpStartInd)
12362{
12363 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12364 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12365
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12366 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12367 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12368 sizeof(tSirMacAddr));
12369
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12370 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12371
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12372 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12373 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12375 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12376 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12377 else if (WDI_STATUS_SUCCESS_SYNC != status)
12378 {
12379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12380 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12381 }
12382
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12383 vos_mem_free(dhcpStartInd);
12384 return CONVERT_WDI2VOS_STATUS(status) ;
12385}
12386
12387 /*
12388 * FUNCTION: WDA_ProcessDHCPStopInd
12389 * Forward DHCP Stop to WDI
12390 */
12391 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12392 tAniDHCPInd *dhcpStopInd)
12393 {
12394 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12395 WDI_DHCPInd wdiDHCPInd;
12396
12397 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12398 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12399
12400 status = WDI_dhcpStopInd(&wdiDHCPInd);
12401
12402 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12403 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12405 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12406 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12407 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12408 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12410 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12411 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12412
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12413 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12414
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12415 return CONVERT_WDI2VOS_STATUS(status) ;
12416 }
12417
12418/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]12419 * FUNCTION: WDA_ProcessSetSpoofMacAddrReq
12420 *
12421 * DESCRIPTION: This function sends Spoof Mac Addr Req to WDI
12422 *
12423 * PARAM:
12424 * pWDA: pointer to WDA context
12425 * pReq: pointer to stop batch scan request
12426 */
12427VOS_STATUS WDA_ProcessSetSpoofMacAddrReq(tWDA_CbContext *pWDA,
12428 tpSpoofMacAddrReqParams pReq)
12429{
12430 WDI_Status wdiStatus;
12431 WDI_SpoofMacAddrInfoType *WDI_SpoofMacAddrInfoParams;
12432 tWDA_ReqParams *pWdaParams;
12433
12434 WDI_SpoofMacAddrInfoParams = (WDI_SpoofMacAddrInfoType *)vos_mem_malloc(
12435 sizeof(WDI_SpoofMacAddrInfoType));
12436 if(NULL == WDI_SpoofMacAddrInfoParams) {
12437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12438 "%s: VOS MEM Alloc Failure in Spoof Req", __func__);
12439 VOS_ASSERT(0);
12440 return VOS_STATUS_E_NOMEM;
12441 }
12442 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12443 if(NULL == pWdaParams) {
12444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12445 "%s: VOS MEM Alloc Failure", __func__);
12446 VOS_ASSERT(0);
12447 return VOS_STATUS_E_NOMEM;
12448 }
12449
12450 vos_mem_copy(WDI_SpoofMacAddrInfoParams->macAddr,
12451 pReq->macAddr, VOS_MAC_ADDRESS_LEN);
12452
12453 pWdaParams->pWdaContext = pWDA;
12454 /* Store Upper layer req pointer, as this will be used for response */
12455 pWdaParams->wdaMsgParam = (void *)pReq ;
12456 /* store Params pass it to WDI */
12457 pWdaParams->wdaWdiApiMsgParam = (void *)WDI_SpoofMacAddrInfoParams ;
12458
12459 wdiStatus = WDI_SetSpoofMacAddrReq(WDI_SpoofMacAddrInfoParams,
12460 (WDI_SetSpoofMacAddrRspCb) WDA_SpoofMacAddrRspCallback,
12461 pWdaParams );
12462
12463 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12464 {
12465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12466 "Failure in SetSpoofMacAddrReq Params WDI API, free all the memory " );
12467 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12468 vos_mem_free(pWdaParams->wdaMsgParam);
12469 vos_mem_free(pWdaParams);
12470 }
12471
12472 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
12473}
12474
12475/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12476 * FUNCTION: WDA_McProcessMsg
12477 * Trigger DAL-AL to start CFG download
12478 */
12479VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12480{
12481 VOS_STATUS status = VOS_STATUS_SUCCESS;
12482 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12483 if(NULL == pMsg)
12484 {
12485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12486 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12487 VOS_ASSERT(0);
12488 return VOS_STATUS_E_FAILURE;
12489 }
12490
12491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12492 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12493
12494 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12495 if(NULL == pWDA )
12496 {
12497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12498 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12499 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12500 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12501 return VOS_STATUS_E_FAILURE;
12502 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12503 /* Process all the WDA messages.. */
12504 switch( pMsg->type )
12505 {
12506 case WNI_CFG_DNLD_REQ:
12507 {
12508 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12509 /* call WDA complete event if config download success */
12510 if( VOS_IS_STATUS_SUCCESS(status) )
12511 {
12512 vos_WDAComplete_cback(pVosContext);
12513 }
12514 else
12515 {
12516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12517 "WDA Config Download failure" );
12518 }
12519 break ;
12520 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12521 /*
12522 * Init SCAN request from PE, convert it into DAL format
12523 * and send it to DAL
12524 */
12525 case WDA_INIT_SCAN_REQ:
12526 {
12527 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12528 break ;
12529 }
12530 /* start SCAN request from PE */
12531 case WDA_START_SCAN_REQ:
12532 {
12533 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12534 break ;
12535 }
12536 /* end SCAN request from PE */
12537 case WDA_END_SCAN_REQ:
12538 {
12539 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12540 break ;
12541 }
12542 /* end SCAN request from PE */
12543 case WDA_FINISH_SCAN_REQ:
12544 {
12545 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12546 break ;
12547 }
12548 /* join request from PE */
12549 case WDA_CHNL_SWITCH_REQ:
12550 {
12551 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12552 {
12553 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12554 }
12555 else
12556 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12557 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12558 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12559 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12560 {
12561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12562 "call ProcessChannelSwitchReq_V1" );
12563 WDA_ProcessChannelSwitchReq_V1(pWDA,
12564 (tSwitchChannelParams*)pMsg->bodyptr) ;
12565 }
12566 else
12567 {
12568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12569 "call ProcessChannelSwitchReq" );
12570 WDA_ProcessChannelSwitchReq(pWDA,
12571 (tSwitchChannelParams*)pMsg->bodyptr) ;
12572 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12573 }
12574 break ;
12575 }
12576 /* ADD BSS request from PE */
12577 case WDA_ADD_BSS_REQ:
12578 {
12579 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12580 break ;
12581 }
12582 case WDA_ADD_STA_REQ:
12583 {
12584 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12585 break ;
12586 }
12587 case WDA_DELETE_BSS_REQ:
12588 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12589 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12590 break ;
12591 }
12592 case WDA_DELETE_STA_REQ:
12593 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12594 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12595 break ;
12596 }
12597 case WDA_CONFIG_PARAM_UPDATE_REQ:
12598 {
12599 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12600 break ;
12601 }
12602 case WDA_SET_BSSKEY_REQ:
12603 {
12604 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12605 break ;
12606 }
12607 case WDA_SET_STAKEY_REQ:
12608 {
12609 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12610 break ;
12611 }
12612 case WDA_SET_STA_BCASTKEY_REQ:
12613 {
12614 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12615 break ;
12616 }
12617 case WDA_REMOVE_BSSKEY_REQ:
12618 {
12619 WDA_ProcessRemoveBssKeyReq(pWDA,
12620 (tRemoveBssKeyParams *)pMsg->bodyptr);
12621 break ;
12622 }
12623 case WDA_REMOVE_STAKEY_REQ:
12624 {
12625 WDA_ProcessRemoveStaKeyReq(pWDA,
12626 (tRemoveStaKeyParams *)pMsg->bodyptr);
12627 break ;
12628 }
12629 case WDA_REMOVE_STA_BCASTKEY_REQ:
12630 {
12631 /* TODO: currently UMAC is not sending this request, Add the code for
12632 handling this request when UMAC supports */
12633 break;
12634 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12635#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12636 case WDA_TSM_STATS_REQ:
12637 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12638 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12639 break;
12640 }
12641#endif
12642 case WDA_UPDATE_EDCA_PROFILE_IND:
12643 {
12644 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12645 break;
12646 }
12647 case WDA_ADD_TS_REQ:
12648 {
12649 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12650 break;
12651 }
12652 case WDA_DEL_TS_REQ:
12653 {
12654 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12655 break;
12656 }
12657 case WDA_ADDBA_REQ:
12658 {
12659 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12660 break;
12661 }
12662 case WDA_DELBA_IND:
12663 {
12664 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12665 break;
12666 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12667 case WDA_UPDATE_CHAN_LIST_REQ:
12668 {
12669 WDA_ProcessUpdateChannelList(pWDA,
12670 (tSirUpdateChanList *)pMsg->bodyptr);
12671 break;
12672 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12673 case WDA_SET_LINK_STATE:
12674 {
12675 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12676 break;
12677 }
12678 case WDA_GET_STATISTICS_REQ:
12679 {
12680 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12681 break;
12682 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12683#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12684 case WDA_GET_ROAM_RSSI_REQ:
12685 {
12686 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12687 break;
12688 }
12689#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12690 case WDA_PWR_SAVE_CFG:
12691 {
12692 if(pWDA->wdaState == WDA_READY_STATE)
12693 {
12694 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12695 }
12696 else
12697 {
12698 if(NULL != pMsg->bodyptr)
12699 {
12700 vos_mem_free(pMsg->bodyptr);
12701 }
12702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12703 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12704 }
12705 break;
12706 }
12707 case WDA_ENTER_IMPS_REQ:
12708 {
12709 if(pWDA->wdaState == WDA_READY_STATE)
12710 {
12711 WDA_ProcessEnterImpsReq(pWDA);
12712 }
12713 else
12714 {
12715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12716 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12717 }
12718 break;
12719 }
12720 case WDA_EXIT_IMPS_REQ:
12721 {
12722 if(pWDA->wdaState == WDA_READY_STATE)
12723 {
12724 WDA_ProcessExitImpsReq(pWDA);
12725 }
12726 else
12727 {
12728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12729 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12730 }
12731 break;
12732 }
12733 case WDA_ENTER_BMPS_REQ:
12734 {
12735 if(pWDA->wdaState == WDA_READY_STATE)
12736 {
12737 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12738 }
12739 else
12740 {
12741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12742 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12743 }
12744 break;
12745 }
12746 case WDA_EXIT_BMPS_REQ:
12747 {
12748 if(pWDA->wdaState == WDA_READY_STATE)
12749 {
12750 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12751 }
12752 else
12753 {
12754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12755 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12756 }
12757 break;
12758 }
12759 case WDA_ENTER_UAPSD_REQ:
12760 {
12761 if(pWDA->wdaState == WDA_READY_STATE)
12762 {
12763 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12764 }
12765 else
12766 {
12767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12768 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12769 }
12770 break;
12771 }
12772 case WDA_EXIT_UAPSD_REQ:
12773 {
12774 if(pWDA->wdaState == WDA_READY_STATE)
12775 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12776 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12777 }
12778 else
12779 {
12780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12781 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12782 }
12783 break;
12784 }
12785 case WDA_UPDATE_UAPSD_IND:
12786 {
12787 if(pWDA->wdaState == WDA_READY_STATE)
12788 {
12789 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12790 }
12791 else
12792 {
12793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12794 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12795 }
12796 break;
12797 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12798 case WDA_REGISTER_PE_CALLBACK :
12799 {
12800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12801 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12802 /*TODO: store the PE callback */
12803 /* Do Nothing? MSG Body should be freed at here */
12804 if(NULL != pMsg->bodyptr)
12805 {
12806 vos_mem_free(pMsg->bodyptr);
12807 }
12808 break;
12809 }
12810 case WDA_SYS_READY_IND :
12811 {
12812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12813 "Handling msg type WDA_SYS_READY_IND " );
12814 pWDA->wdaState = WDA_READY_STATE;
12815 if(NULL != pMsg->bodyptr)
12816 {
12817 vos_mem_free(pMsg->bodyptr);
12818 }
12819 break;
12820 }
12821 case WDA_BEACON_FILTER_IND :
12822 {
12823 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12824 break;
12825 }
12826 case WDA_BTC_SET_CFG:
12827 {
12828 /*TODO: handle this while dealing with BTC */
12829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12830 "Handling msg type WDA_BTC_SET_CFG " );
12831 /* Do Nothing? MSG Body should be freed at here */
12832 if(NULL != pMsg->bodyptr)
12833 {
12834 vos_mem_free(pMsg->bodyptr);
12835 }
12836 break;
12837 }
12838 case WDA_SIGNAL_BT_EVENT:
12839 {
12840 /*TODO: handle this while dealing with BTC */
12841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12842 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12843 /* Do Nothing? MSG Body should be freed at here */
12844 if(NULL != pMsg->bodyptr)
12845 {
12846 vos_mem_free(pMsg->bodyptr);
12847 }
12848 break;
12849 }
12850 case WDA_CFG_RXP_FILTER_REQ:
12851 {
12852 WDA_ProcessConfigureRxpFilterReq(pWDA,
12853 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12854 break;
12855 }
12856 case WDA_SET_HOST_OFFLOAD:
12857 {
12858 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12859 break;
12860 }
12861 case WDA_SET_KEEP_ALIVE:
12862 {
12863 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12864 break;
12865 }
12866#ifdef WLAN_NS_OFFLOAD
12867 case WDA_SET_NS_OFFLOAD:
12868 {
12869 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12870 break;
12871 }
12872#endif //WLAN_NS_OFFLOAD
12873 case WDA_ADD_STA_SELF_REQ:
12874 {
12875 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12876 break;
12877 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12878 case WDA_DEL_STA_SELF_REQ:
12879 {
12880 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12881 break;
12882 }
12883 case WDA_WOWL_ADD_BCAST_PTRN:
12884 {
12885 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12886 break;
12887 }
12888 case WDA_WOWL_DEL_BCAST_PTRN:
12889 {
12890 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12891 break;
12892 }
12893 case WDA_WOWL_ENTER_REQ:
12894 {
12895 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12896 break;
12897 }
12898 case WDA_WOWL_EXIT_REQ:
12899 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12900 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12901 break;
12902 }
12903 case WDA_TL_FLUSH_AC_REQ:
12904 {
12905 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12906 break;
12907 }
12908 case WDA_SIGNAL_BTAMP_EVENT:
12909 {
12910 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12911 break;
12912 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12913#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12914 case WDA_LINK_LAYER_STATS_SET_REQ:
12915 {
12916 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12917 break;
12918 }
12919 case WDA_LINK_LAYER_STATS_GET_REQ:
12920 {
12921 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12922 break;
12923 }
12924 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12925 {
12926 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12927 break;
12928 }
12929#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12930#ifdef WLAN_FEATURE_EXTSCAN
12931 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12932 {
12933 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12934 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12935 break;
12936 }
12937 case WDA_EXTSCAN_START_REQ:
12938 {
12939 WDA_ProcessEXTScanStartReq(pWDA,
12940 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12941 break;
12942 }
12943 case WDA_EXTSCAN_STOP_REQ:
12944 {
12945 WDA_ProcessEXTScanStopReq(pWDA,
12946 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12947 break;
12948 }
12949 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12950 {
12951 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12952 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12953 break;
12954 }
12955 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12956 {
12957 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12958 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12959 break;
12960 }
12961 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12962 {
12963 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12964 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12965 break;
12966 }
12967 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12968 {
12969 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12970 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12971 break;
12972 }
12973 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12974 {
12975 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12976 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12977 break;
12978 }
12979#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12980#ifdef WDA_UT
12981 case WDA_WDI_EVENT_MSG:
12982 {
12983 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12984 break ;
12985 }
12986#endif
12987 case WDA_UPDATE_BEACON_IND:
12988 {
12989 WDA_ProcessUpdateBeaconParams(pWDA,
12990 (tUpdateBeaconParams *)pMsg->bodyptr);
12991 break;
12992 }
12993 case WDA_SEND_BEACON_REQ:
12994 {
12995 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12996 break;
12997 }
12998 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12999 {
13000 WDA_ProcessUpdateProbeRspTemplate(pWDA,
13001 (tSendProbeRespParams *)pMsg->bodyptr);
13002 break;
13003 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]13004#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13005 case WDA_SET_MAX_TX_POWER_REQ:
13006 {
13007 WDA_ProcessSetMaxTxPowerReq(pWDA,
13008 (tMaxTxPowerParams *)pMsg->bodyptr);
13009 break;
13010 }
13011#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]13012 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
13013 {
13014 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
13015 pMsg->bodyptr);
13016 break;
13017 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]13018 case WDA_SET_TX_POWER_REQ:
13019 {
13020 WDA_ProcessSetTxPowerReq(pWDA,
13021 (tSirSetTxPowerReq *)pMsg->bodyptr);
13022 break;
13023 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13024 case WDA_SET_P2P_GO_NOA_REQ:
13025 {
13026 WDA_ProcessSetP2PGONOAReq(pWDA,
13027 (tP2pPsParams *)pMsg->bodyptr);
13028 break;
13029 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13030 /* timer related messages */
13031 case WDA_TIMER_BA_ACTIVITY_REQ:
13032 {
13033 WDA_BaCheckActivity(pWDA) ;
13034 break ;
13035 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13036
13037 /* timer related messages */
13038 case WDA_TIMER_TRAFFIC_STATS_IND:
13039 {
13040 WDA_TimerTrafficStatsInd(pWDA);
13041 break;
13042 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13043#ifdef WLAN_FEATURE_VOWIFI_11R
13044 case WDA_AGGR_QOS_REQ:
13045 {
13046 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
13047 break;
13048 }
13049#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13050 case WDA_FTM_CMD_REQ:
13051 {
13052 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
13053 break ;
13054 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13055#ifdef FEATURE_OEM_DATA_SUPPORT
13056 case WDA_START_OEM_DATA_REQ:
13057 {
13058 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
13059 break;
13060 }
13061#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13062 /* Tx Complete Time out Indication */
13063 case WDA_TX_COMPLETE_TIMEOUT_IND:
13064 {
13065 WDA_ProcessTxCompleteTimeOutInd(pWDA);
13066 break;
13067 }
13068 case WDA_WLAN_SUSPEND_IND:
13069 {
13070 WDA_ProcessWlanSuspendInd(pWDA,
13071 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
13072 break;
13073 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13074 case WDA_WLAN_RESUME_REQ:
13075 {
13076 WDA_ProcessWlanResumeReq(pWDA,
13077 (tSirWlanResumeParam *)pMsg->bodyptr) ;
13078 break;
13079 }
13080
13081 case WDA_UPDATE_CF_IND:
13082 {
13083 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
13084 pMsg->bodyptr = NULL;
13085 break;
13086 }
13087#ifdef FEATURE_WLAN_SCAN_PNO
13088 case WDA_SET_PNO_REQ:
13089 {
13090 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
13091 break;
13092 }
13093 case WDA_UPDATE_SCAN_PARAMS_REQ:
13094 {
13095 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
13096 break;
13097 }
13098 case WDA_SET_RSSI_FILTER_REQ:
13099 {
13100 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
13101 break;
13102 }
13103#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13104#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13105 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13106 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13107 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13108 break;
13109 }
13110#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13111 case WDA_SET_TX_PER_TRACKING_REQ:
13112 {
13113 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
13114 break;
13115 }
13116
13117#ifdef WLAN_FEATURE_PACKET_FILTERING
13118 case WDA_8023_MULTICAST_LIST_REQ:
13119 {
13120 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
13121 break;
13122 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13123 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
13124 {
13125 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
13126 break;
13127 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13128 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
13129 {
13130 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
13131 break;
13132 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13133 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
13134 {
13135 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
13136 break;
13137 }
13138#endif // WLAN_FEATURE_PACKET_FILTERING
13139
13140
13141 case WDA_TRANSMISSION_CONTROL_IND:
13142 {
13143 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
13144 break;
13145 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13146 case WDA_SET_POWER_PARAMS_REQ:
13147 {
13148 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
13149 break;
13150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13151#ifdef WLAN_FEATURE_GTK_OFFLOAD
13152 case WDA_GTK_OFFLOAD_REQ:
13153 {
13154 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
13155 break;
13156 }
13157
13158 case WDA_GTK_OFFLOAD_GETINFO_REQ:
13159 {
13160 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
13161 break;
13162 }
13163#endif //WLAN_FEATURE_GTK_OFFLOAD
13164
13165 case WDA_SET_TM_LEVEL_REQ:
13166 {
13167 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
13168 break;
13169 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13170
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13171 case WDA_UPDATE_OP_MODE:
13172 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13173 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
13174 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
13175 {
13176 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13177 }
13178 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13179 {
13180 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
13181 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13182 else
13183 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13184 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13185 }
13186 else
13187 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13188 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13189 break;
13190 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]13191#ifdef WLAN_FEATURE_11W
13192 case WDA_EXCLUDE_UNENCRYPTED_IND:
13193 {
13194 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
13195 break;
13196 }
13197#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13198#ifdef FEATURE_WLAN_TDLS
13199 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
13200 {
13201 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
13202 break;
13203 }
13204#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13205 case WDA_DHCP_START_IND:
13206 {
13207 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13208 break;
13209 }
13210 case WDA_DHCP_STOP_IND:
13211 {
13212 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13213 break;
13214 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13215#ifdef FEATURE_WLAN_LPHB
13216 case WDA_LPHB_CONF_REQ:
13217 {
13218 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
13219 break;
13220 }
13221#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13222 case WDA_ADD_PERIODIC_TX_PTRN_IND:
13223 {
13224 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
13225 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
13226 break;
13227 }
13228 case WDA_DEL_PERIODIC_TX_PTRN_IND:
13229 {
13230 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
13231 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
13232 break;
13233 }
13234
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13235#ifdef FEATURE_WLAN_BATCH_SCAN
13236 case WDA_SET_BATCH_SCAN_REQ:
13237 {
13238 WDA_ProcessSetBatchScanReq(pWDA,
13239 (tSirSetBatchScanReq *)pMsg->bodyptr);
13240 break;
13241 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13242 case WDA_RATE_UPDATE_IND:
13243 {
13244 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
13245 break;
13246 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13247 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
13248 {
13249 WDA_ProcessTriggerBatchScanResultInd(pWDA,
13250 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
13251 break;
13252 }
13253 case WDA_STOP_BATCH_SCAN_IND:
13254 {
13255 WDA_ProcessStopBatchScanInd(pWDA,
13256 (tSirStopBatchScanInd *)pMsg->bodyptr);
13257 break;
13258 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]13259 case WDA_GET_BCN_MISS_RATE_REQ:
13260 WDA_ProcessGetBcnMissRateReq(pWDA,
13261 (tSirBcnMissRateReq *)pMsg->bodyptr);
13262 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13263#endif
13264
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13265 case WDA_HT40_OBSS_SCAN_IND:
13266 {
13267 WDA_ProcessHT40OBSSScanInd(pWDA,
13268 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
13269 break;
13270 }
13271 case WDA_HT40_OBSS_STOP_SCAN_IND:
13272 {
13273 WDA_ProcessHT40OBSSStopScanInd(pWDA,
13274 (tANI_U8*)pMsg->bodyptr);
13275 break;
13276 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]13277// tdlsoffchan
13278#ifdef FEATURE_WLAN_TDLS
13279 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
13280 {
13281 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
13282 break;
13283 }
13284#endif
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13285 case WDA_SPOOF_MAC_ADDR_REQ:
13286 {
13287 WDA_ProcessSetSpoofMacAddrReq(pWDA, (tpSpoofMacAddrReqParams)pMsg->bodyptr);
13288 break;
13289 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13290 default:
13291 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]13292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13293 "No Handling for msg type %x in WDA "
13294 ,pMsg->type);
13295 /* Do Nothing? MSG Body should be freed at here */
13296 if(NULL != pMsg->bodyptr)
13297 {
13298 vos_mem_free(pMsg->bodyptr);
13299 }
13300 //WDA_VOS_ASSERT(0) ;
13301 }
13302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13303 return status ;
13304}
13305
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13306/*
13307 * FUNCTION: WDA_LowLevelIndCallback
13308 * IND API callback from WDI, send Ind to PE
13309 */
13310void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
13311 void* pUserData )
13312{
13313 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
13314#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13315 tSirRSSINotification rssiNotification;
13316#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13317 if(NULL == pWDA)
13318 {
13319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13320 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13321 VOS_ASSERT(0);
13322 return ;
13323 }
13324
13325 switch(wdiLowLevelInd->wdiIndicationType)
13326 {
13327 case WDI_RSSI_NOTIFICATION_IND:
13328 {
13329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13330 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13331#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13332 rssiNotification.bReserved =
13333 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
13334 rssiNotification.bRssiThres1NegCross =
13335 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
13336 rssiNotification.bRssiThres1PosCross =
13337 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
13338 rssiNotification.bRssiThres2NegCross =
13339 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
13340 rssiNotification.bRssiThres2PosCross =
13341 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
13342 rssiNotification.bRssiThres3NegCross =
13343 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
13344 rssiNotification.bRssiThres3PosCross =
13345 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]13346 rssiNotification.avgRssi = (v_S7_t)
13347 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13348 WLANTL_BMPSRSSIRegionChangedNotification(
13349 pWDA->pVosContext,
13350 &rssiNotification);
13351#endif
13352 break ;
13353 }
13354 case WDI_MISSED_BEACON_IND:
13355 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13356 tpSirSmeMissedBeaconInd pMissBeacInd =
13357 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13359 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13360 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13361 if(NULL == pMissBeacInd)
13362 {
13363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13364 "%s: VOS MEM Alloc Failure", __func__);
13365 break;
13366 }
13367 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13368 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13369 pMissBeacInd->bssIdx =
13370 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13371 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13372 break ;
13373 }
13374 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13375 {
13376 /* TODO: Decode Ind and send Ind to PE */
13377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13378 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13379 break ;
13380 }
13381
13382 case WDI_MIC_FAILURE_IND:
13383 {
13384 tpSirSmeMicFailureInd pMicInd =
13385 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13386
13387 if(NULL == pMicInd)
13388 {
13389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13390 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13391 break;
13392 }
13393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13394 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13395 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13396 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13397 vos_mem_copy(pMicInd->bssId,
13398 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13399 sizeof(tSirMacAddr));
13400 vos_mem_copy(pMicInd->info.srcMacAddr,
13401 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13402 sizeof(tSirMacAddr));
13403 vos_mem_copy(pMicInd->info.taMacAddr,
13404 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13405 sizeof(tSirMacAddr));
13406 vos_mem_copy(pMicInd->info.dstMacAddr,
13407 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13408 sizeof(tSirMacAddr));
13409 vos_mem_copy(pMicInd->info.rxMacAddr,
13410 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13411 sizeof(tSirMacAddr));
13412 pMicInd->info.multicast =
13413 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13414 pMicInd->info.keyId=
13415 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13416 pMicInd->info.IV1=
13417 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13418 vos_mem_copy(pMicInd->info.TSC,
13419 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13420 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13421 (void *)pMicInd , 0) ;
13422 break ;
13423 }
13424 case WDI_FATAL_ERROR_IND:
13425 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13426 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13427 /* TODO: Decode Ind and send Ind to PE */
13428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13429 "Received WDI_FATAL_ERROR_IND from WDI ");
13430 break ;
13431 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13432 case WDI_DEL_STA_IND:
13433 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13434 tpDeleteStaContext pDelSTACtx =
13435 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13436
13437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13438 "Received WDI_DEL_STA_IND from WDI ");
13439 if(NULL == pDelSTACtx)
13440 {
13441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13442 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13443 break;
13444 }
13445 vos_mem_copy(pDelSTACtx->addr2,
13446 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13447 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13448 vos_mem_copy(pDelSTACtx->bssId,
13449 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13450 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13451 pDelSTACtx->assocId =
13452 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13453 pDelSTACtx->reasonCode =
13454 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13455 pDelSTACtx->staId =
13456 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13457 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13458 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13459 break ;
13460 }
13461 case WDI_COEX_IND:
13462 {
13463 tANI_U32 index;
13464 vos_msg_t vosMsg;
13465 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13466 if(NULL == pSmeCoexInd)
13467 {
13468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13469 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13470 break;
13471 }
13472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13473 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13474 /* Message Header */
13475 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13476 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13477 /* Info from WDI Indication */
13478 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13479 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13480 {
13481 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13482 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13483 /* VOS message wrapper */
13484 vosMsg.type = eWNI_SME_COEX_IND;
13485 vosMsg.bodyptr = (void *)pSmeCoexInd;
13486 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13487 /* Send message to SME */
13488 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13489 {
13490 /* free the mem and return */
13491 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13492 }
13493 else
13494 {
13495 /* DEBUG */
13496 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13497 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13498 pSmeCoexInd->coexIndType,
13499 pSmeCoexInd->coexIndData[0],
13500 pSmeCoexInd->coexIndData[1],
13501 pSmeCoexInd->coexIndData[2],
13502 pSmeCoexInd->coexIndData[3]);
13503 }
13504 break;
13505 }
13506 case WDI_TX_COMPLETE_IND:
13507 {
13508 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13509 /* Calling TxCompleteAck Indication from wda context*/
13510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13511 "Complete Indication received from HAL");
13512 if( pWDA->pAckTxCbFunc )
13513 {
13514 if( VOS_STATUS_SUCCESS !=
13515 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13516 {
13517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13518 "Tx Complete timeout Timer Stop Failed ");
13519 }
13520 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13521 pWDA->pAckTxCbFunc = NULL;
13522 }
13523 else
13524 {
13525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13526 "Tx Complete Indication is received after timeout ");
13527 }
13528 break;
13529 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13530 case WDI_P2P_NOA_START_IND :
13531 {
13532 tSirP2PNoaStart *pP2pNoaStart =
13533 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13534
13535 if (NULL == pP2pNoaStart)
13536 {
13537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13538 "Memory allocation failure, "
13539 "WDI_P2P_NOA_START_IND not forwarded");
13540 break;
13541 }
13542 pP2pNoaStart->status =
13543 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13544 pP2pNoaStart->bssIdx =
13545 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13546 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13547 (void *)pP2pNoaStart , 0) ;
13548 break;
13549 }
13550
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13551#ifdef FEATURE_WLAN_TDLS
13552 case WDI_TDLS_IND :
13553 {
13554 tSirTdlsInd *pTdlsInd =
13555 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13556
13557 if (NULL == pTdlsInd)
13558 {
13559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13560 "Memory allocation failure, "
13561 "WDI_TDLS_IND not forwarded");
13562 break;
13563 }
13564 pTdlsInd->status =
13565 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13566 pTdlsInd->assocId =
13567 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13568 pTdlsInd->staIdx =
13569 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13570 pTdlsInd->reasonCode =
13571 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13572 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13573 (void *)pTdlsInd , 0) ;
13574 break;
13575 }
13576#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13577 case WDI_P2P_NOA_ATTR_IND :
13578 {
13579 tSirP2PNoaAttr *pP2pNoaAttr =
13580 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13582 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13583 if (NULL == pP2pNoaAttr)
13584 {
13585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13586 "Memory allocation failure, "
13587 "WDI_P2P_NOA_ATTR_IND not forwarded");
13588 break;
13589 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13590 pP2pNoaAttr->index =
13591 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13592 pP2pNoaAttr->oppPsFlag =
13593 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13594 pP2pNoaAttr->ctWin =
13595 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13596
13597 pP2pNoaAttr->uNoa1IntervalCnt =
13598 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13599 pP2pNoaAttr->uNoa1Duration =
13600 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13601 pP2pNoaAttr->uNoa1Interval =
13602 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13603 pP2pNoaAttr->uNoa1StartTime =
13604 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13605 pP2pNoaAttr->uNoa2IntervalCnt =
13606 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13607 pP2pNoaAttr->uNoa2Duration =
13608 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13609 pP2pNoaAttr->uNoa2Interval =
13610 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13611 pP2pNoaAttr->uNoa2StartTime =
13612 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13613 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13614 (void *)pP2pNoaAttr , 0) ;
13615 break;
13616 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13617#ifdef FEATURE_WLAN_SCAN_PNO
13618 case WDI_PREF_NETWORK_FOUND_IND:
13619 {
13620 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13621 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13622 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13623 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13624 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13625
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13626 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13627 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13628 if (NULL == pPrefNetworkFoundInd)
13629 {
13630 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13631 "Memory allocation failure, "
13632 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13633 if (NULL !=
13634 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13635 {
13636 wpalMemoryFree(
13637 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13638 );
13639 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13641 break;
13642 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13643 /* Message Header */
13644 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13645 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13646
13647 /* Info from WDI Indication */
13648 pPrefNetworkFoundInd->ssId.length =
13649 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13650 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13651 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13652 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13653 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13654 if (NULL !=
13655 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13656 {
13657 pPrefNetworkFoundInd->frameLength =
13658 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13659 vos_mem_copy( pPrefNetworkFoundInd->data,
13660 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13661 pPrefNetworkFoundInd->frameLength);
13662 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13663 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13664 }
13665 else
13666 {
13667 pPrefNetworkFoundInd->frameLength = 0;
13668 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13669 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13670 /* VOS message wrapper */
13671 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13672 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13673 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13674 /* Send message to SME */
13675 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13676 {
13677 /* free the mem and return */
13678 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13679 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13680 break;
13681 }
13682#endif // FEATURE_WLAN_SCAN_PNO
13683
13684#ifdef WLAN_WAKEUP_EVENTS
13685 case WDI_WAKE_REASON_IND:
13686 {
13687 vos_msg_t vosMsg;
13688 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13689 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13690 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13691
13692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13693 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13694 wdiLowLevelInd->wdiIndicationType,
13695 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13696 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13697 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13698
13699 if (NULL == pWakeReasonInd)
13700 {
13701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13702 "Memory allocation failure, "
13703 "WDI_WAKE_REASON_IND not forwarded");
13704 break;
13705 }
13706
13707 vos_mem_zero(pWakeReasonInd, allocSize);
13708
13709 /* Message Header */
13710 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13711 pWakeReasonInd->mesgLen = allocSize;
13712
13713 /* Info from WDI Indication */
13714 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13715 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13716 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13717 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13718 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13719 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13720 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13721 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13722
13723 /* VOS message wrapper */
13724 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13725 vosMsg.bodyptr = (void *) pWakeReasonInd;
13726 vosMsg.bodyval = 0;
13727
13728 /* Send message to SME */
13729 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13730 {
13731 /* free the mem and return */
13732 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13733 }
13734
13735 break;
13736 }
13737#endif // WLAN_WAKEUP_EVENTS
13738
13739 case WDI_TX_PER_HIT_IND:
13740 {
13741 vos_msg_t vosMsg;
13742 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13743 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13744 /* VOS message wrapper */
13745 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13746 vosMsg.bodyptr = NULL;
13747 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13748 /* Send message to SME */
13749 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13750 {
13751 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13752 }
13753 break;
13754 }
13755
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13756#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13757 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13758 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13759 vos_msg_t vosMsg;
13760 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13761
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13762 lphbInd =
13763 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13764 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13765 {
13766 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13767 "%s: LPHB IND buffer alloc Fail", __func__);
13768 return ;
13769 }
13770
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13771 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13772 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13773 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13774 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13775 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13776 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13777
13778 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13779 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13780 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13781
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13782 vosMsg.type = eWNI_SME_LPHB_IND;
13783 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13784 vosMsg.bodyval = 0;
13785 /* Send message to SME */
13786 if (VOS_STATUS_SUCCESS !=
13787 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13788 {
13789 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13790 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13791 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13792 }
13793 break;
13794 }
13795#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13796 case WDI_PERIODIC_TX_PTRN_FW_IND:
13797 {
13798 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13799 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13800 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13801 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13802 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13803 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13804 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13805
13806 break;
13807 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13808
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13809 case WDI_IBSS_PEER_INACTIVITY_IND:
13810 {
13811 tSirIbssPeerInactivityInd *pIbssInd =
13812 (tSirIbssPeerInactivityInd *)
13813 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13814
13815 if (NULL == pIbssInd)
13816 {
13817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13818 "Memory allocation failure, "
13819 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13820 break;
13821 }
13822
13823 pIbssInd->bssIdx =
13824 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13825 pIbssInd->staIdx =
13826 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13827 vos_mem_copy(pIbssInd->peerAddr,
13828 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13829 sizeof(tSirMacAddr));
13830 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13831 break;
13832 }
13833
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13834#ifdef FEATURE_WLAN_BATCH_SCAN
13835 case WDI_BATCH_SCAN_RESULT_IND:
13836 {
13837 void *pBatchScanResult;
13838 void *pCallbackContext;
13839 tpAniSirGlobal pMac;
13840
13841 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13842 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13843
13844 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13845 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13846 {
13847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13848 "%s:pWDA is NULL", __func__);
13849 VOS_ASSERT(0);
13850 return;
13851 }
13852
13853 pBatchScanResult =
13854 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13855 if (NULL == pBatchScanResult)
13856 {
13857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13858 "%s:Batch scan result from FW is null can't invoke HDD callback",
13859 __func__);
13860 VOS_ASSERT(0);
13861 return;
13862 }
13863
13864 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13865 if (NULL == pMac)
13866 {
13867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13868 "%s:pMac is NULL", __func__);
13869 VOS_ASSERT(0);
13870 return;
13871 }
13872
13873 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13874 /*call hdd callback with set batch scan response data*/
13875 if(pMac->pmc.batchScanResultCallback)
13876 {
13877 pMac->pmc.batchScanResultCallback(pCallbackContext,
13878 pBatchScanResult);
13879 }
13880 else
13881 {
13882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13883 "%s:HDD callback is null", __func__);
13884 VOS_ASSERT(0);
13885 }
13886 break;
13887 }
13888#endif
13889
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13890#ifdef FEATURE_WLAN_CH_AVOID
13891 case WDI_CH_AVOID_IND:
13892 {
13893 vos_msg_t vosMsg;
13894 tSirChAvoidIndType *chAvoidInd;
13895
13896 chAvoidInd =
13897 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13898 if (NULL == chAvoidInd)
13899 {
13900 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13901 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13902 return ;
13903 }
13904
13905 chAvoidInd->avoidRangeCount =
13906 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13907 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13908 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13909 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13910
13911 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13912 "%s : WDA CH avoid notification", __func__);
13913
13914 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13915 vosMsg.bodyptr = chAvoidInd;
13916 vosMsg.bodyval = 0;
13917 /* Send message to SME */
13918 if (VOS_STATUS_SUCCESS !=
13919 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13920 {
13921 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13922 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13923 vos_mem_free(chAvoidInd);
13924 }
13925 break;
13926 }
13927#endif /* FEATURE_WLAN_CH_AVOID */
13928
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13929#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13930 case WDI_LL_STATS_RESULTS_IND:
13931 {
13932 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13933 tpAniSirGlobal pMac;
13934
13935 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13936 "Received WDI_LL_STATS_RESULTS_IND from FW");
13937
13938 /*sanity check*/
13939 if (NULL == pWDA)
13940 {
13941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13942 "%s:pWDA is NULL", __func__);
13943 VOS_ASSERT(0);
13944 return;
13945 }
13946
13947 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13948 (void *)wdiLowLevelInd->
13949 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13950 if (NULL == pLinkLayerStatsInd)
13951 {
13952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13953 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13954 __func__);
13955 VOS_ASSERT(0);
13956 return;
13957 }
13958
13959 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13960 if (NULL == pMac)
13961 {
13962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13963 "%s:pMac is NULL", __func__);
13964 VOS_ASSERT(0);
13965 return;
13966 }
13967
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13968 /* call hdd callback with Link Layer Statistics.
13969 * vdev_id/ifacId in link_stats_results will be
13970 * used to retrieve the correct HDD context
13971 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13972 if (pMac->sme.pLinkLayerStatsIndCallback)
13973 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13974 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13975 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13976 pLinkLayerStatsInd,
13977 wdiLowLevelInd->
13978 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13979 }
13980 else
13981 {
13982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13983 "%s:HDD callback is null", __func__);
13984 }
13985 break;
13986 }
13987#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13988
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13989#ifdef WLAN_FEATURE_EXTSCAN
13990 case WDI_EXTSCAN_PROGRESS_IND:
13991 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13992 case WDI_EXTSCAN_SCAN_RESULT_IND:
13993 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13994 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13995 {
13996 void *pEXTScanData;
13997 void *pCallbackContext;
13998 tpAniSirGlobal pMac;
13999 tANI_U16 indType;
14000
14001 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14002 "Received WDI_EXTSCAN Indications from FW");
14003 /*sanity check*/
14004 if (NULL == pWDA)
14005 {
14006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14007 "%s:pWDA is NULL", __func__);
14008 VOS_ASSERT(0);
14009 return;
14010 }
14011 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
14012 {
14013 indType = WDA_EXTSCAN_PROGRESS_IND;
14014
14015 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14016 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
14017 }
14018 if (wdiLowLevelInd->wdiIndicationType ==
14019 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
14020 {
14021 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
14022
14023 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14024 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
14025 }
14026 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
14027 {
14028 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
14029
14030 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14031 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
14032 }
14033 if (wdiLowLevelInd->wdiIndicationType ==
14034 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
14035 {
14036 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
14037
14038 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14039 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
14040 }
14041 if (wdiLowLevelInd->wdiIndicationType ==
14042 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
14043 {
14044 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
14045
14046 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14047 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
14048 }
14049
14050 pEXTScanData =
14051 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
14052 if (NULL == pEXTScanData)
14053 {
14054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14055 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
14056 __func__);
14057 VOS_ASSERT(0);
14058 return;
14059 }
14060
14061 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14062 if (NULL == pMac)
14063 {
14064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14065 "%s:pMac is NULL", __func__);
14066 VOS_ASSERT(0);
14067 return;
14068 }
14069
14070 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
14071
14072 if(pMac->sme.pEXTScanIndCb)
14073 {
14074 pMac->sme.pEXTScanIndCb(pCallbackContext,
14075 indType,
14076 pEXTScanData);
14077 }
14078 else
14079 {
14080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14081 "%s:HDD callback is null", __func__);
14082 }
14083 break;
14084 }
14085#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]14086 case WDI_DEL_BA_IND:
14087 {
14088 tpBADeleteParams pDelBAInd =
14089 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
14090
14091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14092 "Received WDI_DEL_BA_IND from WDI ");
14093 if(NULL == pDelBAInd)
14094 {
14095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14096 "%s: VOS MEM Alloc Failure", __func__);
14097 break;
14098 }
14099 vos_mem_copy(pDelBAInd->peerMacAddr,
14100 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
14101 sizeof(tSirMacAddr));
14102 vos_mem_copy(pDelBAInd->bssId,
14103 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
14104 sizeof(tSirMacAddr));
14105 pDelBAInd->staIdx =
14106 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
14107 pDelBAInd->baTID =
14108 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
14109 pDelBAInd->baDirection =
14110 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
14111 pDelBAInd->reasonCode =
14112 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
14113
14114 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
14115 (void *)pDelBAInd , 0) ;
14116 break;
14117 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14118
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14119 default:
14120 {
14121 /* TODO error */
14122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14123 "Received UNKNOWN Indication from WDI ");
14124 }
14125 }
14126 return ;
14127}
14128
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14129/*
14130 * BA related processing in WDA.
14131 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14132void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
14133 void* pUserData)
14134{
14135 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14136 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14137 if(NULL == pWdaParams)
14138 {
14139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14140 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14141 VOS_ASSERT(0) ;
14142 return ;
14143 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14144 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14145 vos_mem_free(pWdaParams->wdaMsgParam) ;
14146 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14147 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14149 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14150 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
14151 {
14152 tANI_U8 i = 0 ;
14153 tBaActivityInd *baActivityInd = NULL ;
14154 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
14155 tANI_U8 allocSize = sizeof(tBaActivityInd)
14156 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
14157 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
14158 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14159 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14160 if(NULL == baActivityInd)
14161 {
14162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14163 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14164 VOS_ASSERT(0) ;
14165 return;
14166 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14167 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
14168 sizeof(tSirMacAddr)) ;
14169 baActivityInd->baCandidateCnt = baCandidateCount ;
14170
14171 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
14172 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
14173
14174 for(i = 0 ; i < baCandidateCount ; i++)
14175 {
14176 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14177 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
14178 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14179 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
14180 {
14181 baCandidate->baInfo[tid].fBaEnable =
14182 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
14183 baCandidate->baInfo[tid].startingSeqNum =
14184 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
14185 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]14186 wdiBaCandidate++ ;
14187 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14188 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14189 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
14190 }
14191 else
14192 {
14193 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14194 "BA Trigger RSP with Failure received ");
14195 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14196 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14197}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14198
14199
14200/*
14201 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
14202 * during MCC
14203 */
14204void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
14205{
14206 wpt_uint32 enabled;
14207 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
14208 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
14209 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
14210
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14211 if (NULL == pMac )
14212 {
14213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14214 "%s: Invoked with invalid MAC context ", __func__ );
14215 VOS_ASSERT(0);
14216 return;
14217 }
14218
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14219 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14220 != eSIR_SUCCESS)
14221 {
14222 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14223 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14224 return;
14225 }
14226
14227 if(!enabled)
14228 {
14229 return;
14230 }
14231
14232 if(NULL == pWDA)
14233 {
14234 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14235 "%s:WDA context is NULL", __func__);
14236 VOS_ASSERT(0);
14237 return;
14238 }
14239
14240 if(activate)
14241 {
14242 if( VOS_STATUS_SUCCESS !=
14243 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14244 {
14245 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14246 "Traffic Stats Timer Start Failed ");
14247 return;
14248 }
14249 WDI_DS_ActivateTrafficStats();
14250 }
14251 else
14252 {
14253 WDI_DS_DeactivateTrafficStats();
14254 WDI_DS_ClearTrafficStats();
14255
14256 if( VOS_STATUS_SUCCESS !=
14257 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14258 {
14259 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14260 "Traffic Stats Timer Stop Failed ");
14261 return;
14262 }
14263 }
14264}
14265
14266/*
14267 * Traffic Stats Timer handler
14268 */
14269void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
14270{
14271 WDI_Status wdiStatus;
14272 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
14273 WDI_TrafficStatsIndType trafficStatsIndParams;
14274 wpt_uint32 length, enabled;
14275 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14276
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14277 if (NULL == pMac )
14278 {
14279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14280 "%s: Invoked with invalid MAC context ", __func__ );
14281 VOS_ASSERT(0);
14282 return;
14283 }
14284
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14285 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14286 != eSIR_SUCCESS)
14287 {
14288 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14289 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14290 return;
14291 }
14292
14293 if(!enabled)
14294 {
14295 WDI_DS_DeactivateTrafficStats();
14296 return;
14297 }
14298
14299 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
14300
14301 if(pWdiTrafficStats != NULL)
14302 {
14303 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
14304 trafficStatsIndParams.length = length;
14305 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]14306 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14307 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
14308 trafficStatsIndParams.pUserData = pWDA;
14309
14310 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
14311
14312 if(WDI_STATUS_PENDING == wdiStatus)
14313 {
14314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14315 "Pending received for %s:%d ",__func__,__LINE__ );
14316 }
14317 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
14318 {
14319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14320 "Failure in %s:%d ",__func__,__LINE__ );
14321 }
14322
14323 WDI_DS_ClearTrafficStats();
14324 }
14325 else
14326 {
14327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14328 "pWdiTrafficStats is Null");
14329 }
14330
14331 if( VOS_STATUS_SUCCESS !=
14332 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14333 {
14334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14335 "Traffic Stats Timer Start Failed ");
14336 return;
14337 }
14338}
14339
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14340/*
14341 * BA Activity check timer handler
14342 */
14343void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
14344{
14345 tANI_U8 curSta = 0 ;
14346 tANI_U8 tid = 0 ;
14347 tANI_U8 size = 0 ;
14348 tANI_U8 baCandidateCount = 0 ;
14349 tANI_U8 newBaCandidate = 0 ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14350 tANI_U32 val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14351 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14352 tpAniSirGlobal pMac;
14353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14354 if(NULL == pWDA)
14355 {
14356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14357 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14358 VOS_ASSERT(0);
14359 return ;
14360 }
14361 if(WDA_MAX_STA < pWDA->wdaMaxSta)
14362 {
14363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14364 "Inconsistent STA entries in WDA");
14365 VOS_ASSERT(0) ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14366 }
14367 if(NULL == pWDA->pVosContext)
14368 {
14369 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14370 "%s: pVosContext is NULL",__func__);
14371 VOS_ASSERT(0);
14372 return ;
14373 }
14374 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14375 if (wlan_cfgGetInt(pMac,
14376 WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC, &val) !=
14377 eSIR_SUCCESS)
14378 {
14379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14380 "Unable to get WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC");
14381 val = 0;
14382 }
14383
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14384 /* walk through all STA entries and find out TX packet count */
14385 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
14386 {
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14387 tANI_U32 currentOperChan = pWDA->wdaStaInfo[curSta].currentOperChan;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14388#ifdef WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14389 // We can only do BA on "hard" STAs.
14390 if (!(IS_HWSTA_IDX(curSta)))
14391 {
14392 continue;
14393 }
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14394#endif //WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14395 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
14396 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14397 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14398 tANI_U32 txPktCount = 0 ;
14399 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14400 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14401 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
14402 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14403 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14404 curSta, tid, &txPktCount)))
14405 {
14406#if 0
14407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14408 "************* %d:%d, %d ",curSta, txPktCount,
14409 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14410#endif
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame^]14411 if(val && ( (currentOperChan >= SIR_11B_CHANNEL_BEGIN) &&
14412 (currentOperChan <= SIR_11B_CHANNEL_END)))
14413 {
14414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14415 "%s: BTC disabled aggregation - dont start "
14416 "TX ADDBA req",__func__);
14417 }
14418 else if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14419 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14420 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14421 curSta, tid)))
14422 {
14423 /* get prepare for sending message to HAL */
14424 //baCandidate[baCandidateCount].staIdx = curSta ;
14425 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14426 newBaCandidate = WDA_ENABLE_BA ;
14427 }
14428 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14429 }
14430 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14431 /* fill the entry for all the sta with given TID's */
14432 if(WDA_ENABLE_BA == newBaCandidate)
14433 {
14434 /* move to next BA candidate */
14435 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14436 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14437 baCandidateCount++ ;
14438 newBaCandidate = WDA_DISABLE_BA ;
14439 }
14440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14441 /* prepare and send message to hal */
14442 if( 0 < baCandidateCount)
14443 {
14444 WDI_Status status = WDI_STATUS_SUCCESS ;
14445 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14446 tWDA_ReqParams *pWdaParams =
14447 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14448 if(NULL == pWdaParams)
14449 {
14450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14451 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14452 VOS_ASSERT(0) ;
14453 return;
14454 }
14455 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14456 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14457 if(NULL == wdiTriggerBaReq)
14458 {
14459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14460 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14461 VOS_ASSERT(0) ;
14462 vos_mem_free(pWdaParams);
14463 return;
14464 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14465 do
14466 {
14467 WDI_TriggerBAReqinfoType *triggerBaInfo =
14468 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14469 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14470 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14471 * for each request */
14472 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14473 triggerBaInfo->ucBASessionID = 0;
14474 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14475 } while(0) ;
14476 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14478 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14479 pWdaParams->pWdaContext = pWDA;
14480 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14481 pWdaParams->wdaMsgParam = NULL;
14482 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14483 WDA_TriggerBaReqCallback, pWdaParams) ;
14484 if(IS_WDI_STATUS_FAILURE(status))
14485 {
14486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14487 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14488 vos_mem_free(pWdaParams->wdaMsgParam) ;
14489 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14490 vos_mem_free(pWdaParams) ;
14491 }
14492 }
14493 else
14494 {
14495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14496 "There is no TID for initiating BA");
14497 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14498 if( VOS_STATUS_SUCCESS !=
14499 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14500 {
14501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14502 "BA Activity Timer Stop Failed ");
14503 return ;
14504 }
14505 if( VOS_STATUS_SUCCESS !=
14506 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14507 {
14508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14509 "BA Activity Timer Start Failed ");
14510 return;
14511 }
14512 return ;
14513}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14514/*
14515 * WDA common routine to create timer used by WDA.
14516 */
14517static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14518{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14519 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14520 tANI_U32 val = 0 ;
14521 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14522
14523 if(NULL == pMac)
14524 {
14525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14526 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14527 VOS_ASSERT(0);
14528 return VOS_STATUS_E_FAILURE;
14529 }
14530 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14531 != eSIR_SUCCESS)
14532 {
14533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14534 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14535 return VOS_STATUS_E_FAILURE;
14536 }
14537 val = SYS_MS_TO_TICKS(val) ;
14538
14539 /* BA activity check timer */
14540 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14541 "BA Activity Check timer", WDA_TimerHandler,
14542 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14543 if(status != TX_SUCCESS)
14544 {
14545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14546 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14547 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14548 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14549 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14550 /* Tx Complete Timeout timer */
14551 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14552 "Tx Complete Check timer", WDA_TimerHandler,
14553 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14554 if(status != TX_SUCCESS)
14555 {
14556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14557 "Unable to create Tx Complete Timeout timer");
14558 /* Destroy timer of BA activity check timer */
14559 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14560 if(status != TX_SUCCESS)
14561 {
14562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14563 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14564 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14565 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14566 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14567 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14568
14569 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14570
14571 /* Traffic Stats timer */
14572 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14573 "Traffic Stats timer", WDA_TimerHandler,
14574 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14575 if(status != TX_SUCCESS)
14576 {
14577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14578 "Unable to create traffic stats timer");
14579 /* Destroy timer of BA activity check timer */
14580 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14581 if(status != TX_SUCCESS)
14582 {
14583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14584 "Unable to Destroy BA activity timer");
14585 }
14586 /* Destroy timer of tx complete timer */
14587 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14588 if(status != TX_SUCCESS)
14589 {
14590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14591 "Unable to Tx complete timer");
14592 }
14593 return VOS_STATUS_E_FAILURE ;
14594 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14595 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14596}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14597/*
14598 * WDA common routine to destroy timer used by WDA.
14599 */
14600static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14601{
14602 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14603 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14604 if(status != TX_SUCCESS)
14605 {
14606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14607 "Unable to Destroy Tx Complete Timeout timer");
14608 return eSIR_FAILURE ;
14609 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14610 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14611 if(status != TX_SUCCESS)
14612 {
14613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14614 "Unable to Destroy BA activity timer");
14615 return eSIR_FAILURE ;
14616 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14617 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14618 if(status != TX_SUCCESS)
14619 {
14620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14621 "Unable to Destroy traffic stats timer");
14622 return eSIR_FAILURE ;
14623 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14624 return eSIR_SUCCESS ;
14625}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14626/*
14627 * WDA timer handler.
14628 */
14629void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14630{
14631 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14632 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14633 /*
14634 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14635 */
14636 wdaMsg.type = timerInfo ;
14637 wdaMsg.bodyptr = NULL;
14638 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14639 /* post the message.. */
14640 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14641 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14642 {
14643 vosStatus = VOS_STATUS_E_BADMSG;
14644 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14645}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14646/*
14647 * WDA Tx Complete timeout Indication.
14648 */
14649void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14650{
14651 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14652 if( pWDA->pAckTxCbFunc )
14653 {
14654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14655 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14656 pWDA->pAckTxCbFunc( pMac, 0);
14657 pWDA->pAckTxCbFunc = NULL;
14658 }
14659 else
14660 {
14661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14662 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14663 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14664}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14665/*
14666 * WDA Set REG Domain to VOS NV
14667 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14668eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14669 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14670{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14671 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14672 {
14673 return eHAL_STATUS_INVALID_PARAMETER;
14674 }
14675 return eHAL_STATUS_SUCCESS;
14676}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14677
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14678#ifdef FEATURE_WLAN_SCAN_PNO
14679/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14680 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14681 *
14682 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14683void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14684{
14685 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14686 tSirPNOScanReq *pPNOScanReqParams;
14687
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14689 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14690 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14691 {
14692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14693 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14694 VOS_ASSERT(0) ;
14695 return ;
14696 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14697
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14698 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14699 if(pPNOScanReqParams->statusCallback)
14700 {
14701 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14702 (status == WDI_STATUS_SUCCESS) ?
14703 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14704 }
14705
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14706 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14707 vos_mem_free(pWdaParams->wdaMsgParam);
14708 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14709
14710 return ;
14711}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14712/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14713 * FUNCTION: WDA_PNOScanReqCallback
14714 * Free memory.
14715 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14716 */
14717void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14718{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14719 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14720 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14721
14722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14723 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14724
14725 if(NULL == pWdaParams)
14726 {
14727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14728 "%s: pWdaParams received NULL", __func__);
14729 VOS_ASSERT(0);
14730 return;
14731 }
14732
14733 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14734 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14735 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14736 if(pPNOScanReqParams->statusCallback)
14737 {
14738 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14739 VOS_STATUS_E_FAILURE);
14740 }
14741
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14742 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14743 vos_mem_free(pWdaParams->wdaMsgParam);
14744 vos_mem_free(pWdaParams);
14745 }
14746
14747 return;
14748}
14749/*
14750 * FUNCTION: WDA_UpdateScanParamsRespCallback
14751 *
14752 */
14753void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14754{
14755 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14757 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14758 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14759 {
14760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14761 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14762 VOS_ASSERT(0) ;
14763 return ;
14764 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14765
14766 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14767 vos_mem_free(pWdaParams->wdaMsgParam);
14768 vos_mem_free(pWdaParams);
14769
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14770 return ;
14771}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14772/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14773 * FUNCTION: WDA_UpdateScanParamsReqCallback
14774 * Free memory.
14775 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14776 */
14777void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14778{
14779 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14780
14781 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14782 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14783
14784 if(NULL == pWdaParams)
14785 {
14786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14787 "%s: pWdaParams received NULL", __func__);
14788 VOS_ASSERT(0);
14789 return;
14790 }
14791
14792 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14793 {
14794 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14795 vos_mem_free(pWdaParams->wdaMsgParam);
14796 vos_mem_free(pWdaParams);
14797 }
14798
14799 return;
14800}
14801/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14802 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14803 * Request to WDI to set Preferred Network List.Offload
14804 */
14805VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14806 tSirPNOScanReq *pPNOScanReqParams)
14807{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14808 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14809 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14810 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14811 tWDA_ReqParams *pWdaParams ;
14812 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14814 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14815 if(NULL == pwdiPNOScanReqInfo)
14816 {
14817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14818 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14819 VOS_ASSERT(0);
14820 return VOS_STATUS_E_NOMEM;
14821 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14822 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14823 if(NULL == pWdaParams)
14824 {
14825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14826 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14827 VOS_ASSERT(0);
14828 vos_mem_free(pwdiPNOScanReqInfo);
14829 return VOS_STATUS_E_NOMEM;
14830 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14831 //
14832 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14833 //
14834 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14835 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14836 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14837 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14838 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14839 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14840 {
14841 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14842 &pPNOScanReqParams->aNetworks[i],
14843 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14844 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14845 /*Scan timer intervals*/
14846 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14847 &pPNOScanReqParams->scanTimers,
14848 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14849 /*Probe template for 2.4GHz band*/
14850 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14851 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14852 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14853 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14854 pPNOScanReqParams->p24GProbeTemplate,
14855 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14856 /*Probe template for 5GHz band*/
14857 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14858 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14859 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14860 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14861 pPNOScanReqParams->p5GProbeTemplate,
14862 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14863 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14864 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14865
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14866 /* Store Params pass it to WDI */
14867 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14868 pWdaParams->pWdaContext = pWDA;
14869 /* Store param pointer as passed in by caller */
14870 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14871 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14872 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14873 if(IS_WDI_STATUS_FAILURE(status))
14874 {
14875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14876 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14877 if(pPNOScanReqParams->statusCallback)
14878 {
14879 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14880 VOS_STATUS_E_FAILURE);
14881 }
14882
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14883 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14884 vos_mem_free(pWdaParams->wdaMsgParam);
14885 pWdaParams->wdaWdiApiMsgParam = NULL;
14886 pWdaParams->wdaMsgParam = NULL;
14887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14888 return CONVERT_WDI2VOS_STATUS(status) ;
14889}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14890
14891#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14892
14893void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14894{
14895 /*Convert the CSR Auth types to WDI Auth types */
14896 switch (csrAuthType)
14897 {
14898 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14899 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14900 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14901#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14902 case eCSR_AUTH_TYPE_CCKM_WPA:
14903 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14904 break;
14905#endif
14906 case eCSR_AUTH_TYPE_WPA:
14907 *AuthType = eWDA_AUTH_TYPE_WPA;
14908 break;
14909 case eCSR_AUTH_TYPE_WPA_PSK:
14910 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14911 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14912#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14913 case eCSR_AUTH_TYPE_CCKM_RSN:
14914 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14915 break;
14916#endif
14917 case eCSR_AUTH_TYPE_RSN:
14918 *AuthType = eWDA_AUTH_TYPE_RSN;
14919 break;
14920 case eCSR_AUTH_TYPE_RSN_PSK:
14921 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14922 break;
14923#if defined WLAN_FEATURE_VOWIFI_11R
14924 case eCSR_AUTH_TYPE_FT_RSN:
14925 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14926 break;
14927 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14928 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14929 break;
14930#endif
14931#ifdef FEATURE_WLAN_WAPI
14932 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14933 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14934 break;
14935 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14936 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14937 break;
14938#endif /* FEATURE_WLAN_WAPI */
14939 case eCSR_AUTH_TYPE_SHARED_KEY:
14940 case eCSR_AUTH_TYPE_AUTOSWITCH:
14941 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14942 break;
14943#if 0
14944 case eCSR_AUTH_TYPE_SHARED_KEY:
14945 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14946 break;
14947 case eCSR_AUTH_TYPE_AUTOSWITCH:
14948 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14949#endif
14950 default:
14951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14952 "%s: Unknown Auth Type", __func__);
14953 break;
14954 }
14955}
14956void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14957{
14958 switch (csrEncrType)
14959 {
14960 case eCSR_ENCRYPT_TYPE_NONE:
14961 *EncrType = WDI_ED_NONE;
14962 break;
14963 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14964 case eCSR_ENCRYPT_TYPE_WEP40:
14965 *EncrType = WDI_ED_WEP40;
14966 break;
14967 case eCSR_ENCRYPT_TYPE_WEP104:
14968 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14969 *EncrType = WDI_ED_WEP104;
14970 break;
14971 case eCSR_ENCRYPT_TYPE_TKIP:
14972 *EncrType = WDI_ED_TKIP;
14973 break;
14974 case eCSR_ENCRYPT_TYPE_AES:
14975 *EncrType = WDI_ED_CCMP;
14976 break;
14977#ifdef WLAN_FEATURE_11W
14978 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14979 *EncrType = WDI_ED_AES_128_CMAC;
14980 break;
14981#endif
14982#ifdef FEATURE_WLAN_WAPI
14983 case eCSR_ENCRYPT_TYPE_WPI:
14984 *EncrType = WDI_ED_WPI;
14985 break;
14986#endif
14987 case eCSR_ENCRYPT_TYPE_ANY:
14988 *EncrType = WDI_ED_ANY;
14989 break;
14990
14991 default:
14992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14993 "%s: Unknown Encryption Type", __func__);
14994 break;
14995 }
14996}
14997
14998/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14999 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15000 * Request to WDI to set Roam Offload Scan
15001 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15002VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15003 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
15004{
15005 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15006 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
15007 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15008 tWDA_ReqParams *pWdaParams ;
15009 v_U8_t csrAuthType;
15010 WDI_RoamNetworkType *pwdiRoamNetworkType;
15011 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
15012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15013 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15014 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15015 {
15016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15017 "%s: VOS MEM Alloc Failure", __func__);
15018 VOS_ASSERT(0);
15019 return VOS_STATUS_E_NOMEM;
15020 }
15021 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15022 if (NULL == pWdaParams)
15023 {
15024 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15025 "%s: VOS MEM Alloc Failure", __func__);
15026 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15027 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15028 return VOS_STATUS_E_NOMEM;
15029 }
15030
15031 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15032 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15033 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15034 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
15035 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15036 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
15037 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
15038 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
15039 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
15040 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
15041 sizeof(pwdiRoamNetworkType->currAPbssid));
15042 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
15043 csrAuthType);
15044 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
15045 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
15046 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
15047 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
15048 pwdiRoamOffloadScanInfo->LookupThreshold =
15049 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]15050 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
15051 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15052 pwdiRoamOffloadScanInfo->RoamRssiDiff =
15053 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]15054 pwdiRoamOffloadScanInfo->MAWCEnabled =
15055 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15056 pwdiRoamOffloadScanInfo->Command =
15057 pRoamOffloadScanReqParams->Command ;
15058 pwdiRoamOffloadScanInfo->StartScanReason =
15059 pRoamOffloadScanReqParams->StartScanReason ;
15060 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
15061 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
15062 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
15063 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
15064 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
15065 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
15066 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
15067 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
15068 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
15069 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]15070 pwdiRoamOffloadScanInfo->IsESEEnabled =
15071 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15072 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
15073 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
15074 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
15075 pwdiRoamNetworkType->ssId.ucLength =
15076 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
15077 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
15078 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
15079 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
15080 pwdiRoamNetworkType->ChannelCount =
15081 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
15082 pwdiRoamOffloadScanInfo->ChannelCacheType =
15083 pRoamOffloadScanReqParams->ChannelCacheType;
15084 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
15085 pRoamOffloadScanReqParams->ValidChannelList,
15086 pRoamOffloadScanReqParams->ValidChannelCount);
15087 pwdiRoamOffloadScanInfo->ValidChannelCount =
15088 pRoamOffloadScanReqParams->ValidChannelCount;
15089 pwdiRoamOffloadScanInfo->us24GProbeSize =
15090 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15091 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15092 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
15093 pRoamOffloadScanReqParams->p24GProbeTemplate,
15094 pwdiRoamOffloadScanInfo->us24GProbeSize);
15095 pwdiRoamOffloadScanInfo->us5GProbeSize =
15096 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15097 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15098 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
15099 pRoamOffloadScanReqParams->p5GProbeTemplate,
15100 pwdiRoamOffloadScanInfo->us5GProbeSize);
15101 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
15102 pRoamOffloadScanReqParams->MDID.mdiePresent;
15103 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
15104 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15105 pwdiRoamOffloadScanInfo->nProbes =
15106 pRoamOffloadScanReqParams->nProbes;
15107 pwdiRoamOffloadScanInfo->HomeAwayTime =
15108 pRoamOffloadScanReqParams->HomeAwayTime;
15109 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15110 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15111 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15112 pWdaParams->pWdaContext = pWDA;
15113 /* Store param pointer as passed in by caller */
15114 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15115 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15116 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
15117 if(IS_WDI_STATUS_FAILURE(status))
15118 {
15119 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15120 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
15121 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15122 vos_mem_free(pWdaParams->wdaMsgParam);
15123 pWdaParams->wdaWdiApiMsgParam = NULL;
15124 pWdaParams->wdaMsgParam = NULL;
15125 }
15126 return CONVERT_WDI2VOS_STATUS(status) ;
15127}
15128#endif
15129
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15130/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15131 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15132 *
15133 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15134void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15135{
15136 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15137
15138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15139 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15140
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15141 if(NULL == pWdaParams)
15142 {
15143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15144 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15145 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15146 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15147 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15148
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15149 vos_mem_free(pWdaParams->wdaMsgParam) ;
15150 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15151 vos_mem_free(pWdaParams) ;
15152
15153 return ;
15154}
15155/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15156 * FUNCTION: WDA_RssiFilterReqCallback
15157 * Free memory.
15158 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
15159 */
15160void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15161{
15162 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15163
15164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15165 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15166
15167 if(NULL == pWdaParams)
15168 {
15169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15170 "%s: pWdaParams received NULL", __func__);
15171 VOS_ASSERT(0);
15172 return;
15173 }
15174
15175 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15176 {
15177 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15178 vos_mem_free(pWdaParams->wdaMsgParam);
15179 vos_mem_free(pWdaParams);
15180 }
15181
15182 return;
15183}
15184/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15185 * FUNCTION: WDA_ProcessSetPreferredNetworkList
15186 * Request to WDI to set Preferred Network List.Offload
15187 */
15188VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
15189 tSirSetRSSIFilterReq* pRssiFilterParams)
15190{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15191 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15192 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
15193 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
15194 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15196 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15197 if(NULL == pwdiSetRssiFilterReqInfo)
15198 {
15199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15200 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15201 VOS_ASSERT(0);
15202 return VOS_STATUS_E_NOMEM;
15203 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15204 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15205 if(NULL == pWdaParams)
15206 {
15207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15208 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15209 VOS_ASSERT(0);
15210 vos_mem_free(pwdiSetRssiFilterReqInfo);
15211 return VOS_STATUS_E_NOMEM;
15212 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15213 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15214 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
15215 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15216
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15217 /* Store Params pass it to WDI */
15218 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
15219 pWdaParams->pWdaContext = pWDA;
15220 /* Store param pointer as passed in by caller */
15221 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15222 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15223 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15224 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15225 if(IS_WDI_STATUS_FAILURE(status))
15226 {
15227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15228 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
15229 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15230 vos_mem_free(pWdaParams->wdaMsgParam);
15231 pWdaParams->wdaWdiApiMsgParam = NULL;
15232 pWdaParams->wdaMsgParam = NULL;
15233 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15234 return CONVERT_WDI2VOS_STATUS(status) ;
15235}
15236
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15237/*
15238 * FUNCTION: WDA_ProcessUpdateScanParams
15239 * Request to WDI to update Scan Parameters
15240 */
15241VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
15242 tSirUpdateScanParams *pUpdateScanParams)
15243{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15244 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15245 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
15246 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
15247 sizeof(WDI_UpdateScanParamsInfoType)) ;
15248 tWDA_ReqParams *pWdaParams ;
15249 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15251 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15252 if(NULL == wdiUpdateScanParamsInfoType)
15253 {
15254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15255 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15256 VOS_ASSERT(0);
15257 return VOS_STATUS_E_NOMEM;
15258 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15259 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15260 if ( NULL == pWdaParams )
15261 {
15262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15263 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15264 VOS_ASSERT(0);
15265 vos_mem_free(wdiUpdateScanParamsInfoType);
15266 return VOS_STATUS_E_NOMEM;
15267 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15268 //
15269 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
15270 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15272 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
15273 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
15274 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]15275 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15276 pUpdateScanParams->b11dEnabled,
15277 pUpdateScanParams->b11dResolved,
15278 pUpdateScanParams->ucChannelCount,
15279 pUpdateScanParams->usPassiveMinChTime,
15280 pUpdateScanParams->usPassiveMaxChTime,
15281 pUpdateScanParams->usActiveMinChTime,
15282 pUpdateScanParams->usActiveMaxChTime,
15283 sizeof(tSirUpdateScanParams),
15284 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
15285
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15286 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
15287 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15288 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
15289 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15290 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
15291 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15292 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
15293 pUpdateScanParams->usActiveMaxChTime;
15294 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
15295 pUpdateScanParams->usActiveMinChTime;
15296 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
15297 pUpdateScanParams->usPassiveMaxChTime;
15298 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
15299 pUpdateScanParams->usPassiveMinChTime;
15300
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15301 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]15302 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
15303 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15304
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15305 for ( i = 0; i <
15306 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
15307 i++)
15308 {
15309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15310 "Update Scan Parameters channel: %d",
15311 pUpdateScanParams->aChannels[i]);
15312
15313 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
15314 pUpdateScanParams->aChannels[i];
15315 }
15316
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15317 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
15318 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15319
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15320 /* Store Params pass it to WDI */
15321 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
15322 pWdaParams->pWdaContext = pWDA;
15323 /* Store param pointer as passed in by caller */
15324 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15325
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15326
15327
15328 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15329 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15330 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15331 if(IS_WDI_STATUS_FAILURE(status))
15332 {
15333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15334 "Failure in Update Scan Params EQ WDI API, free all the memory " );
15335 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15336 vos_mem_free(pWdaParams->wdaMsgParam);
15337 vos_mem_free(pWdaParams);
15338 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15339 return CONVERT_WDI2VOS_STATUS(status) ;
15340}
15341#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15342
15343#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
15344/*
15345 * FUNCTION: WDA_RoamOffloadScanReqCallback
15346 *
15347 */
15348void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
15349{
15350 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15351 vos_msg_t vosMsg;
15352 wpt_uint8 reason = 0;
15353
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]15354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15355 "<------ %s " ,__func__);
15356 if (NULL == pWdaParams)
15357 {
15358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15359 "%s: pWdaParams received NULL", __func__);
15360 VOS_ASSERT(0) ;
15361 return ;
15362 }
15363 if ( pWdaParams != NULL )
15364 {
15365 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
15366 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15367 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15368 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15369 }
15370 if ( pWdaParams->wdaMsgParam != NULL)
15371 {
15372 vos_mem_free(pWdaParams->wdaMsgParam);
15373 }
15374
15375 vos_mem_free(pWdaParams) ;
15376 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15377 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
15378 vosMsg.bodyptr = NULL;
15379 if (WDI_STATUS_SUCCESS != status)
15380 {
15381 reason = 0;
15382 }
15383 vosMsg.bodyval = reason;
15384 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15385 {
15386 /* free the mem and return */
15387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]15388 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15389 }
15390
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15391 return ;
15392}
15393#endif
15394
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15395/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15396 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15397 *
15398 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15399void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15400{
15401 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15402
15403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15404 "<------ %s " ,__func__);
15405
15406 if(NULL == pWdaParams)
15407 {
15408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15409 "%s: pWdaParams received NULL", __func__);
15410 VOS_ASSERT(0);
15411 return;
15412 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15413
15414 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15415 vos_mem_free(pWdaParams->wdaMsgParam);
15416 vos_mem_free(pWdaParams);
15417
15418 return;
15419}
15420/*
15421 * FUNCTION: WDA_SetPowerParamsReqCallback
15422 * Free memory.
15423 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15424 */
15425void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15426{
15427 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15428
15429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15430 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15431
15432 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15433 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15435 "%s: pWdaParams received NULL", __func__);
15436 VOS_ASSERT(0);
15437 return;
15438 }
15439
15440 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15441 {
15442 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15443 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15444 vos_mem_free(pWdaParams);
15445 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15446
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15447 return;
15448}
15449
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15450#ifdef WLAN_FEATURE_PACKET_FILTERING
15451/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15452 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15453 *
15454 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15455void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15456 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15457 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15458{
15459 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15461 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15462 if(NULL == pWdaParams)
15463 {
15464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15465 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15466 VOS_ASSERT(0) ;
15467 return ;
15468 }
15469
15470 vos_mem_free(pWdaParams->wdaMsgParam) ;
15471 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15472 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15473 //print a msg, nothing else to do
15474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15475 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15476 return ;
15477}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15478/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15479 * FUNCTION: WDA_8023MulticastListReqCallback
15480 * Free memory.
15481 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15482 */
15483void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15484{
15485 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15486
15487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15488 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15489
15490 if(NULL == pWdaParams)
15491 {
15492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15493 "%s: pWdaParams received NULL", __func__);
15494 VOS_ASSERT(0);
15495 return;
15496 }
15497
15498 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15499 {
15500 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15501 vos_mem_free(pWdaParams->wdaMsgParam);
15502 vos_mem_free(pWdaParams);
15503 }
15504
15505 return;
15506}
15507/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15508 * FUNCTION: WDA_Process8023MulticastListReq
15509 * Request to WDI to add 8023 Multicast List
15510 */
15511VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15512 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15513{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15514 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15515 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15516 tWDA_ReqParams *pWdaParams ;
15517 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15519 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15520 pwdiFltPktSetMcListReqParamsType =
15521 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15522 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15523 ) ;
15524 if(NULL == pwdiFltPktSetMcListReqParamsType)
15525 {
15526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15527 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15528 return VOS_STATUS_E_NOMEM;
15529 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15530 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15531 if(NULL == pWdaParams)
15532 {
15533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15534 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15535 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15536 return VOS_STATUS_E_NOMEM;
15537 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15538
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15539 //
15540 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15541 //
15542 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15543 pRcvFltMcAddrList->ulMulticastAddrCnt;
15544
15545 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15546 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15547 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15548 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15549
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15550 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15551 {
15552 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15553 &(pRcvFltMcAddrList->multicastAddr[i]),
15554 sizeof(tSirMacAddr));
15555 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15556 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15557 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15558
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15559 /* Store Params pass it to WDI */
15560 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15561 pWdaParams->pWdaContext = pWDA;
15562 /* Store param pointer as passed in by caller */
15563 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15564 status = WDI_8023MulticastListReq(
15565 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15566 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15567 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15568 if(IS_WDI_STATUS_FAILURE(status))
15569 {
15570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15571 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15572 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15573 vos_mem_free(pWdaParams->wdaMsgParam);
15574 vos_mem_free(pWdaParams);
15575 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15576 return CONVERT_WDI2VOS_STATUS(status) ;
15577}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15578/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15579 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15580 *
15581 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15582void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15583 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15584 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15585{
15586 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15588 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15589 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15590 if(NULL == pWdaParams)
15591 {
15592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15593 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15594 VOS_ASSERT(0) ;
15595 return ;
15596 }
15597
15598 vos_mem_free(pWdaParams->wdaMsgParam) ;
15599 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15600 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15601 //print a msg, nothing else to do
15602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15603 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15604 return ;
15605}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15606
15607/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15608 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15609 * Free memory.
15610 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15611 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15612void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15613 void* pUserData)
15614{
15615 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15616
15617 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15618 "<------ %s, wdiStatus: %d",
15619 __func__, wdiStatus);
15620
15621 if (NULL == pWdaParams)
15622 {
15623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15624 "%s: Invalid pWdaParams pointer", __func__);
15625 VOS_ASSERT(0);
15626 return;
15627 }
15628
15629 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15630 {
15631 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15632 vos_mem_free(pWdaParams->wdaMsgParam);
15633 vos_mem_free(pWdaParams);
15634 }
15635
15636 return;
15637}
15638
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15639/*
15640 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15641 * Request to WDI to set Receive Filters
15642 */
15643VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15644 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15645{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15646 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15647 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15648 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15649 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15650 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15651 tWDA_ReqParams *pWdaParams ;
15652 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15654 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15655 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15656 {
15657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15658 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15659 VOS_ASSERT(0);
15660 return VOS_STATUS_E_NOMEM;
15661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15662 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15663 if(NULL == pWdaParams)
15664 {
15665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15666 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15667 VOS_ASSERT(0);
15668 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15669 return VOS_STATUS_E_NOMEM;
15670 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15671 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15672 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15673 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15674 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15675 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15676 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15677
15678 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15679 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15680
15681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15682 "FID %d FT %d NParams %d CT %d",
15683 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15684 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15685 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15686 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15687 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15688 {
15689 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15690 &pRcvPktFilterCfg->paramsData[i],
15691 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15693 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15694 pwdiSetRcvPktFilterReqParamsType->
15695 wdiPktFilterCfg.paramsData[i].protocolLayer,
15696 pwdiSetRcvPktFilterReqParamsType->
15697 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15699 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15700 pwdiSetRcvPktFilterReqParamsType->
15701 wdiPktFilterCfg.paramsData[i].dataOffset,
15702 pwdiSetRcvPktFilterReqParamsType->
15703 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15705 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15706 pwdiSetRcvPktFilterReqParamsType->
15707 wdiPktFilterCfg.paramsData[i].compareData[0],
15708 pwdiSetRcvPktFilterReqParamsType->
15709 wdiPktFilterCfg.paramsData[i].compareData[1],
15710 pwdiSetRcvPktFilterReqParamsType->
15711 wdiPktFilterCfg.paramsData[i].compareData[2],
15712 pwdiSetRcvPktFilterReqParamsType->
15713 wdiPktFilterCfg.paramsData[i].compareData[3],
15714 pwdiSetRcvPktFilterReqParamsType->
15715 wdiPktFilterCfg.paramsData[i].compareData[4],
15716 pwdiSetRcvPktFilterReqParamsType->
15717 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15719 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15720 pwdiSetRcvPktFilterReqParamsType->
15721 wdiPktFilterCfg.paramsData[i].dataMask[0],
15722 pwdiSetRcvPktFilterReqParamsType->
15723 wdiPktFilterCfg.paramsData[i].dataMask[1],
15724 pwdiSetRcvPktFilterReqParamsType->
15725 wdiPktFilterCfg.paramsData[i].dataMask[2],
15726 pwdiSetRcvPktFilterReqParamsType->
15727 wdiPktFilterCfg.paramsData[i].dataMask[3],
15728 pwdiSetRcvPktFilterReqParamsType->
15729 wdiPktFilterCfg.paramsData[i].dataMask[4],
15730 pwdiSetRcvPktFilterReqParamsType->
15731 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15732 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15733 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15734 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15735 /* Store Params pass it to WDI */
15736 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15737 pWdaParams->pWdaContext = pWDA;
15738 /* Store param pointer as passed in by caller */
15739 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15740 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15741 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15742 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15743 if(IS_WDI_STATUS_FAILURE(status))
15744 {
15745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15746 "Failure in SetFilter(),free all the memory,status %d ",status);
15747 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15748 vos_mem_free(pWdaParams->wdaMsgParam);
15749 vos_mem_free(pWdaParams);
15750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15751 return CONVERT_WDI2VOS_STATUS(status) ;
15752}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15753/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15754 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15755 *
15756 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15757void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15758 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15759 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15760{
15761 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15762 tWDA_CbContext *pWDA;
15763 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15764 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15765 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15766 tANI_U8 i;
15767 vos_msg_t vosMsg;
15768
15769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15770 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15771 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15772
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15773 if(NULL == pRcvFltPktMatchCntRsp)
15774 {
15775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15776 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15777 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15778 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15779 return ;
15780 }
15781
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15782 if(NULL == pWdaParams)
15783 {
15784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15785 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15786 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15787 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15788 return ;
15789 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15790 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15791 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15792 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15793 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15794
15795 /* Message Header */
15796 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15797 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15798
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15799 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15800
15801 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15802 {
15803 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15804 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15806 /* VOS message wrapper */
15807 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15808 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15809 vosMsg.bodyval = 0;
15810 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15811 {
15812 /* free the mem and return */
15813 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15814 }
15815
15816 vos_mem_free(pWdaParams->wdaMsgParam) ;
15817 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15818 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15819
15820 return;
15821}
15822/*
15823 * FUNCTION: WDA_FilterMatchCountReqCallback
15824 * Free memory and send RSP back to SME.
15825 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15826 */
15827void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15828{
15829 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15830 vos_msg_t vosMsg;
15831
15832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15833 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15834
15835 if(NULL == pWdaParams)
15836 {
15837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15838 "%s: pWdaParams received NULL", __func__);
15839 VOS_ASSERT(0);
15840 return;
15841 }
15842
15843 /* VOS message wrapper */
15844 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15845 vosMsg.bodyptr = NULL;
15846 vosMsg.bodyval = 0;
15847
15848 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15849 {
15850 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15851 vos_mem_free(pWdaParams->wdaMsgParam);
15852 vos_mem_free(pWdaParams);
15853 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15854 }
15855
15856 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15857}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15858/*
15859 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15860 * Request to WDI to get PC Filter Match Count
15861 */
15862VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15863{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15864 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15865 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15866 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15867 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15869 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15870 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15871 {
15872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15873 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15874 VOS_ASSERT(0);
15875 return VOS_STATUS_E_NOMEM;
15876 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15877 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15878 if(NULL == pWdaParams)
15879 {
15880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15881 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15882 VOS_ASSERT(0);
15883 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15884 return VOS_STATUS_E_NOMEM;
15885 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15886
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15887 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15888 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15889
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15890 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15891 pRcvFltPktMatchRsp->bssId,
15892 sizeof(wpt_macAddr));
15893
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15894 /* Store Params pass it to WDI */
15895 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15896 pWdaParams->pWdaContext = pWDA;
15897 /* Store param pointer as passed in by caller */
15898 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15899 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15900 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15901 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15902 if(IS_WDI_STATUS_FAILURE(status))
15903 {
15904 /* failure returned by WDI API */
15905 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15906 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15907 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15908 vos_mem_free(pWdaParams) ;
15909 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15910 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15911 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15912 return CONVERT_WDI2VOS_STATUS(status) ;
15913}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15914/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15915 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15916 *
15917 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15918void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15919 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15920 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15921{
15922 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15924 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15925/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15926 if(NULL == pWdaParams)
15927 {
15928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15929 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15930 VOS_ASSERT(0) ;
15931 return ;
15932 }
15933
15934 vos_mem_free(pWdaParams->wdaMsgParam) ;
15935 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15936 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15937 //print a msg, nothing else to do
15938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15939 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15940 return ;
15941}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15942/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15943 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15944 * Free memory.
15945 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15946 */
15947void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15948{
15949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15950
15951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15952 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15953
15954 if(NULL == pWdaParams)
15955 {
15956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15957 "%s: Invalid pWdaParams pointer", __func__);
15958 VOS_ASSERT(0);
15959 return;
15960 }
15961
15962 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15963 {
15964 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15965 vos_mem_free(pWdaParams->wdaMsgParam);
15966 vos_mem_free(pWdaParams);
15967 }
15968
15969 return;
15970}
15971/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15972 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15973 * Request to WDI to clear Receive Filters
15974 */
15975VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15976 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15977{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15978 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15979 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15980 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15981 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15983 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15984 if(NULL == pwdiRcvFltPktClearReqParamsType)
15985 {
15986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15987 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15988 VOS_ASSERT(0);
15989 return VOS_STATUS_E_NOMEM;
15990 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15991 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15992 if(NULL == pWdaParams)
15993 {
15994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15995 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15996 VOS_ASSERT(0);
15997 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15998 return VOS_STATUS_E_NOMEM;
15999 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16000 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
16001 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16002 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
16003 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
16004 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
16005 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16006
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16007 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16008 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16009 /* Store Params pass it to WDI */
16010 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
16011 pWdaParams->pWdaContext = pWDA;
16012 /* Store param pointer as passed in by caller */
16013 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16014 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16015 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16016 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16017 if(IS_WDI_STATUS_FAILURE(status))
16018 {
16019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16020 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
16021 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]16022 vos_mem_free(pWdaParams->wdaMsgParam);
16023 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16024 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16025 return CONVERT_WDI2VOS_STATUS(status) ;
16026}
16027#endif // WLAN_FEATURE_PACKET_FILTERING
16028
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16029/*
16030 * FUNCTION: WDA_ProcessSetPowerParamsReq
16031 * Request to WDI to set power params
16032 */
16033VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
16034 tSirSetPowerParamsReq *pPowerParams)
16035{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]16036 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16037 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
16038 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16039 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16041 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16042 if(NULL == pwdiSetPowerParamsReqInfo)
16043 {
16044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16045 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16046 VOS_ASSERT(0);
16047 return VOS_STATUS_E_NOMEM;
16048 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16049 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16050 if(NULL == pWdaParams)
16051 {
16052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16053 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16054 VOS_ASSERT(0);
16055 vos_mem_free(pwdiSetPowerParamsReqInfo);
16056 return VOS_STATUS_E_NOMEM;
16057 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16058
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16059
16060 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
16061 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16062 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
16063 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16064 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
16065 pPowerParams->uListenInterval;
16066 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
16067 pPowerParams->uBcastMcastFilter;
16068 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
16069 pPowerParams->uEnableBET;
16070 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
16071 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]16072 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
16073 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16074 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
16075 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16076
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16077 /* Store Params pass it to WDI */
16078 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
16079 pWdaParams->pWdaContext = pWDA;
16080 /* Store param pointer as passed in by caller */
16081 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16082 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16083 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16084 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16085 if(IS_WDI_STATUS_FAILURE(status))
16086 {
16087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16088 "Failure in Set power params REQ WDI API, free all the memory " );
16089 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16090 vos_mem_free(pWdaParams->wdaMsgParam);
16091 pWdaParams->wdaWdiApiMsgParam = NULL;
16092 pWdaParams->wdaMsgParam = NULL;
16093 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16094 return CONVERT_WDI2VOS_STATUS(status) ;
16095}
16096
16097/*
16098 * FUNCTION: WDA_SetTmLevelRspCallback
16099 * Set TM Level response
16100 */
16101void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
16102{
16103 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16104
16105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16106 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16107
16108 if(NULL == pWdaParams)
16109 {
16110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16111 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16112 VOS_ASSERT(0) ;
16113 return ;
16114 }
16115
16116 /* Dose not need to send notification to upper layer
16117 * Just free allocated resources */
16118 if( pWdaParams != NULL )
16119 {
16120 if( pWdaParams->wdaWdiApiMsgParam != NULL )
16121 {
16122 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16123 }
16124 vos_mem_free(pWdaParams->wdaMsgParam) ;
16125 vos_mem_free(pWdaParams) ;
16126 }
16127}
16128
16129/*
16130 * FUNCTION: WDA_ProcessSetTmLevelReq
16131 * Set TM Level request
16132 */
16133VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
16134 tAniSetTmLevelReq *setTmLevelReq)
16135{
16136 WDI_Status status = WDI_STATUS_SUCCESS ;
16137 tWDA_ReqParams *pWdaParams ;
16138 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
16139 (WDI_SetTmLevelReqType *)vos_mem_malloc(
16140 sizeof(WDI_SetTmLevelReqType)) ;
16141 if(NULL == wdiSetTmLevelReq)
16142 {
16143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16144 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16145 VOS_ASSERT(0);
16146 return VOS_STATUS_E_NOMEM;
16147 }
16148
16149 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16150 if(NULL == pWdaParams)
16151 {
16152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16153 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16154 VOS_ASSERT(0);
16155 vos_mem_free(wdiSetTmLevelReq);
16156 return VOS_STATUS_E_NOMEM;
16157 }
16158
16159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16160 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16161
16162 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
16163 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
16164
16165 pWdaParams->pWdaContext = pWDA;
16166 pWdaParams->wdaMsgParam = setTmLevelReq;
16167 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
16168
16169 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
16170 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
16171
16172 if(IS_WDI_STATUS_FAILURE(status))
16173 {
16174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]16175 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16176 vos_mem_free(pWdaParams->wdaMsgParam) ;
16177 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16178 vos_mem_free(pWdaParams) ;
16179 }
16180
16181 return CONVERT_WDI2VOS_STATUS(status) ;
16182}
16183
16184VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
16185 tpTxControlParams pTxCtrlParam)
16186{
16187 VOS_STATUS wdaStatus;
16188
16189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16190 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16191 if( pTxCtrlParam == NULL )
16192 {
16193 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16194 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16195 return VOS_STATUS_E_FAILURE;
16196 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16197 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
16198 {
16199 wdaStatus = WDA_SuspendDataTx(pWDA);
16200 }
16201 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
16202 {
16203 wdaStatus = WDA_ResumeDataTx(pWDA);
16204 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16205 return wdaStatus;
16206}
16207
16208 /* FUNCTION WDA_featureCapsExchange
16209 * WDA API to invoke capability exchange between host and FW.
16210 */
16211void WDA_featureCapsExchange(v_PVOID_t pVosContext)
16212{
16213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16214 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16215 WDI_featureCapsExchangeReq( NULL, pVosContext);
16216}
16217
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]16218/* FUNCTION WDA_disableCapablityFeature
16219 * WDA API to diable Active mode offload in host.
16220 */
16221void WDA_disableCapablityFeature(tANI_U8 feature_index)
16222{
16223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16224 "%s:enter", __func__ );
16225 WDI_disableCapablityFeature(feature_index);
16226}
16227
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16228 /* FUNCTION WDA_getHostWlanFeatCaps
16229 * Wrapper for WDI API, that will return if the feature (enum value).passed
16230 * to this API is supported or not in Host
16231 * return value
16232 * 0 - implies feature is NOT Supported
16233 * any non zero value - implies feature is SUPPORTED
16234 */
16235tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
16236{
16237 return WDI_getHostWlanFeatCaps(featEnumValue);
16238}
16239
16240 /* FUNCTION WDA_getFwWlanFeatCaps
16241 * Wrapper for WDI API, that will return if the feature (enum value).passed
16242 * to this API is supported or not in FW
16243 * return value
16244 * 0 - implies feature is NOT Supported
16245 * any non zero value - implies feature is SUPPORTED
16246 */
16247tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
16248{
16249 return WDI_getFwWlanFeatCaps(featEnumValue);
16250}
16251
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]16252
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16253/*
16254 * FUNCTION: WDA_shutdown
16255 * Shutdown WDA/WDI without handshaking with Riva.
16256 * Synchronous function.
16257 */
16258VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
16259{
16260 WDI_Status wdiStatus;
16261 //tANI_U8 eventIdx = 0;
16262 VOS_STATUS status = VOS_STATUS_SUCCESS;
16263 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16264 if (NULL == pWDA)
16265 {
16266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16267 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16268 VOS_ASSERT(0);
16269 return VOS_STATUS_E_FAILURE;
16270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16271 /* FTM mode stay START_STATE */
16272 if( (WDA_READY_STATE != pWDA->wdaState) &&
16273 (WDA_INIT_STATE != pWDA->wdaState) &&
16274 (WDA_START_STATE != pWDA->wdaState) )
16275 {
16276 VOS_ASSERT(0);
16277 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16278
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16279 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
16280 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16281 {
16282 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16283 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16284 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]16285 else
16286 {
16287 vos_event_destroy(&pWDA->ftmStopDoneEvent);
16288 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16289
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16290 /* call WDI shutdown */
16291 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16292 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
16293 {
16294 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16295 "error in WDA Stop" );
16296 status = VOS_STATUS_E_FAILURE;
16297 }
16298 /* WDI stop is synchrnous, shutdown is complete when it returns */
16299 pWDA->wdaState = WDA_STOP_STATE;
16300
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16301 /* shutdown should perform the stop & close actions. */
16302 /* Destroy the event */
16303 status = vos_event_destroy(&pWDA->txFrameEvent);
16304 if(!VOS_IS_STATUS_SUCCESS(status))
16305 {
16306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16307 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16308 status = VOS_STATUS_E_FAILURE;
16309 }
16310 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
16311 if(!VOS_IS_STATUS_SUCCESS(status))
16312 {
16313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16314 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16315 status = VOS_STATUS_E_FAILURE;
16316 }
16317 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
16318 if(!VOS_IS_STATUS_SUCCESS(status))
16319 {
16320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16321 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16322 status = VOS_STATUS_E_FAILURE;
16323 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16324 /* free WDA context */
16325 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
16326 if ( !VOS_IS_STATUS_SUCCESS(status) )
16327 {
16328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16329 "error in WDA close " );
16330 status = VOS_STATUS_E_FAILURE;
16331 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16332 return status;
16333}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16334
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16335/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16336 * FUNCTION: WDA_setNeedShutdown
16337 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16338 */
16339
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16340void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16341{
16342 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16343 if(pWDA == NULL)
16344 {
16345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16346 "Could not get the WDA Context pointer" );
16347 return;
16348 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16349 pWDA->needShutdown = TRUE;
16350}
16351/*
16352 * FUNCTION: WDA_needShutdown
16353 * WDA needs a shutdown
16354 */
16355
16356v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
16357{
16358 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16359 if(pWDA == NULL)
16360 {
16361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16362 "Could not get the WDA Context pointer" );
16363 return 0;
16364 }
16365 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16366}
16367
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16368#ifdef WLAN_FEATURE_11AC
16369/*
16370 * FUNCTION: WDA_SetBeaconFilterReqCallback
16371 *
16372 */
16373void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
16374{
16375 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16377 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16378 if(NULL == pWdaParams)
16379 {
16380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16381 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16382 VOS_ASSERT(0) ;
16383 return ;
16384 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16385
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16386 vos_mem_free(pWdaParams->wdaMsgParam) ;
16387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16388 vos_mem_free(pWdaParams) ;
16389 /*
16390 * No respone required for SetBeaconFilter req so just free the request
16391 * param here
16392 */
16393
16394 return ;
16395}
16396
16397VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
16398 tUpdateVHTOpMode *pData)
16399{
16400 WDI_Status status = WDI_STATUS_SUCCESS ;
16401 tWDA_ReqParams *pWdaParams ;
16402 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
16403 sizeof(WDI_UpdateVHTOpMode)) ;
16404 if(NULL == wdiTemp)
16405 {
16406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16407 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16408 VOS_ASSERT(0);
16409 return VOS_STATUS_E_NOMEM;
16410 }
16411 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16412 if(NULL == pWdaParams)
16413 {
16414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16415 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16416 VOS_ASSERT(0);
16417 vos_mem_free(wdiTemp);
16418 return VOS_STATUS_E_NOMEM;
16419 }
16420
16421 wdiTemp->opMode = pData->opMode;
16422 wdiTemp->staId = pData->staId;
16423
16424 pWdaParams->pWdaContext = pWDA;
16425 /* Store Req pointer, as this will be used for response */
16426 pWdaParams->wdaMsgParam = (void *)pData;
16427 /* store Params pass it to WDI */
16428 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16429
16430 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16431
16432 if(IS_WDI_STATUS_FAILURE(status))
16433 {
16434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16435 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16436 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16437 vos_mem_free(pWdaParams->wdaMsgParam);
16438 vos_mem_free(pWdaParams);
16439 }
16440 return CONVERT_WDI2VOS_STATUS(status) ;
16441}
16442#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16443
16444/*==========================================================================
16445 FUNCTION WDA_TransportChannelDebug
16446
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16447 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16448 Display Transport Channel debugging information
16449 User may request to display DXE channel snapshot
16450 Or if host driver detects any abnormal stcuk may display
16451
16452 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16453 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16454 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16455 debugFlags : Enable stall detect features
16456 defined by WPAL_DeviceDebugFlags
16457 These features may effect
16458 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16459
16460 RETURN VALUE
16461 NONE
16462
16463===========================================================================*/
16464void WDA_TransportChannelDebug
16465(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16466 tpAniSirGlobal pMac,
16467 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16468 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16469)
16470{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16471 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16472 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16473}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16474
16475/*==========================================================================
16476 FUNCTION WDA_SetEnableSSR
16477
16478 DESCRIPTION
16479 API to enable/disable SSR on WDI timeout
16480
16481 PARAMETERS
16482 enableSSR : enable/disable SSR
16483
16484 RETURN VALUE
16485 NONE
16486
16487===========================================================================*/
16488void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16489{
16490 WDI_SetEnableSSR(enableSSR);
16491}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16492
16493#ifdef FEATURE_WLAN_LPHB
16494/*
16495 * FUNCTION: WDA_LPHBconfRspCallback
16496 *
16497 */
16498void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16499{
16500 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16501
16502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16503 "<------ %s " ,__func__);
16504 if (NULL == pWdaParams)
16505 {
16506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16507 "%s: pWdaParams received NULL", __func__);
16508 VOS_ASSERT(0) ;
16509 return ;
16510 }
16511
16512 /* Do not need to send notification to upper layer
16513 * Just free allocated resources */
16514 if (pWdaParams != NULL)
16515 {
16516 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16517 {
16518 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16519 }
16520 vos_mem_free(pWdaParams->wdaMsgParam) ;
16521 vos_mem_free(pWdaParams) ;
16522 }
16523
16524 return;
16525}
16526
16527/*
16528 * FUNCTION: WDA_ProcessLPHBConfReq
16529 *
16530 */
16531VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16532 tSirLPHBReq *pData)
16533{
16534 WDI_Status wdiStatus;
16535 tWDA_ReqParams *pWdaParams ;
16536
16537 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16538 "------> %s " , __func__);
16539
16540 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16541 if (NULL == pWdaParams)
16542 {
16543 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16544 "%s: VOS MEM Alloc Failure", __func__);
16545 VOS_ASSERT(0);
16546 vos_mem_free(pData);
16547 return VOS_STATUS_E_NOMEM;
16548 }
16549
16550 pWdaParams->pWdaContext = pWDA;
16551 pWdaParams->wdaMsgParam = (void *)pData;
16552 pWdaParams->wdaWdiApiMsgParam = NULL;
16553
16554 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16555 if (WDI_STATUS_PENDING == wdiStatus)
16556 {
16557 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16558 "Pending received for %s:%d ", __func__, __LINE__);
16559 }
16560 else if (WDI_STATUS_SUCCESS != wdiStatus)
16561 {
16562 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16563 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16564 vos_mem_free(pWdaParams->wdaMsgParam);
16565 vos_mem_free(pWdaParams);
16566 }
16567
16568 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16569}
16570#endif /* FEATURE_WLAN_LPHB */
16571
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16572void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16573 void* pUserData)
16574{
16575 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16576
16577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16578 "<------ %s " ,__func__);
16579 if (NULL == pBcnMissRateInfo)
16580 {
16581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16582 "%s: pWdaParams received NULL", __func__);
16583 VOS_ASSERT(0) ;
16584 return ;
16585 }
16586 if (pBcnMissRateInfo->callback)
16587 {
16588 pBcnMissRateInfo->callback(status, bcnMissRate,
16589 pBcnMissRateInfo->data);
16590 }
16591 vos_mem_free(pUserData);
16592
16593 return;
16594}
16595
16596v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16597 tSirBcnMissRateReq *pData)
16598{
16599 WDI_Status wdiStatus;
16600 tSirBcnMissRateInfo *pBcnMissRateInfo;
16601
16602 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16603 "------> %s " , __func__);
16604
16605 pBcnMissRateInfo =
16606 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16607 if (NULL == pBcnMissRateInfo)
16608 {
16609 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16610 "%s: VOS MEM Alloc Failure", __func__);
16611 VOS_ASSERT(0);
16612 vos_mem_free(pData);
16613 return;
16614 }
16615
16616 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16617 pBcnMissRateInfo->data = pData->data;
16618
16619 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16620 WDA_GetBcnMissRateCallback,
16621 pData->bssid);
16622 if (WDI_STATUS_PENDING == wdiStatus)
16623 {
16624 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16625 "Pending received for %s:%d ", __func__, __LINE__);
16626 }
16627 else if (WDI_STATUS_SUCCESS != wdiStatus)
16628 {
16629 if (pBcnMissRateInfo->callback)
16630 {
16631 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16632 -1, pBcnMissRateInfo->data);
16633 }
16634 }
16635 vos_mem_free(pData);
16636}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16637
16638#ifdef WLAN_FEATURE_EXTSCAN
16639
16640/*==========================================================================
16641 FUNCTION WDA_EXTScanStartRspCallback
16642
16643 DESCRIPTION
16644 API to send EXTScan Start Response to HDD
16645
16646 PARAMETERS
16647 pEventData: Response from FW
16648 pUserData:
16649===========================================================================*/
16650void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16651{
16652 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16653 tWDA_CbContext *pWDA = NULL;
16654 void *pCallbackContext;
16655 tpAniSirGlobal pMac;
16656
16657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16658 "%s:", __func__);
16659 if (NULL == pWdaParams)
16660 {
16661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16662 "%s: pWdaParams received NULL", __func__);
16663 VOS_ASSERT(0);
16664 return;
16665 }
16666
16667 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16668
16669 if (NULL == pWDA)
16670 {
16671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16672 "%s: pWDA received NULL", __func__);
16673 VOS_ASSERT(0);
16674 goto error;
16675 }
16676
16677 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16678 if (NULL == pMac)
16679 {
16680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16681 "%s:pMac is NULL", __func__);
16682 VOS_ASSERT(0);
16683 goto error;
16684 }
16685
16686 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16687
16688 if (pMac->sme.pEXTScanIndCb)
16689 {
16690 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16691 pEventData);
16692 }
16693 else
16694 {
16695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16696 "%s:HDD callback is null", __func__);
16697 VOS_ASSERT(0);
16698 }
16699
16700error:
16701
16702 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16703 {
16704 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16705 }
16706 if (pWdaParams->wdaMsgParam != NULL)
16707 {
16708 vos_mem_free(pWdaParams->wdaMsgParam);
16709 }
16710 vos_mem_free(pWdaParams) ;
16711
16712 return;
16713}
16714
16715/*==========================================================================
16716 FUNCTION WDA_EXTScanStopRspCallback
16717
16718 DESCRIPTION
16719 API to send EXTScan Stop Response to HDD
16720
16721 PARAMETERS
16722 pEventData: Response from FW
16723 pUserData:
16724===========================================================================*/
16725void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16726{
16727 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16728 tWDA_CbContext *pWDA = NULL;
16729 void *pCallbackContext;
16730 tpAniSirGlobal pMac;
16731
16732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16733 "%s:", __func__);
16734 if (NULL == pWdaParams)
16735 {
16736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16737 "%s: pWdaParams received NULL", __func__);
16738 VOS_ASSERT(0);
16739 return;
16740 }
16741
16742 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16743
16744 if (NULL == pWDA)
16745 {
16746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16747 "%s: pWDA received NULL", __func__);
16748 VOS_ASSERT(0);
16749 goto error;
16750 }
16751
16752 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16753 if (NULL == pMac)
16754 {
16755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16756 "%s:pMac is NULL", __func__);
16757 VOS_ASSERT(0);
16758 goto error;
16759 }
16760 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16761
16762 if (pMac->sme.pEXTScanIndCb)
16763 {
16764 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16765 "%s:HDD call back function called", __func__);
16766 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16767 pEventData);
16768 }
16769 else
16770 {
16771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16772 "%s:HDD callback is null", __func__);
16773 VOS_ASSERT(0);
16774 }
16775
16776error:
16777
16778 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16779 {
16780 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16781 }
16782 if (pWdaParams->wdaMsgParam != NULL)
16783 {
16784 vos_mem_free(pWdaParams->wdaMsgParam);
16785 }
16786 vos_mem_free(pWdaParams) ;
16787
16788
16789 return;
16790}
16791
16792/*==========================================================================
16793 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16794
16795 DESCRIPTION
16796 API to send EXTScan Get Cached Results Response to HDD
16797
16798 PARAMETERS
16799 pEventData: Response from FW
16800 pUserData:
16801===========================================================================*/
16802void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16803{
16804 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16805 tWDA_CbContext *pWDA = NULL;
16806 void *pCallbackContext;
16807 tpAniSirGlobal pMac;
16808
16809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16810 "%s: ", __func__);
16811 if (NULL == pWdaParams)
16812 {
16813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16814 "%s: pWdaParams received NULL", __func__);
16815 VOS_ASSERT(0);
16816 return;
16817 }
16818
16819 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16820
16821 if (NULL == pWDA)
16822 {
16823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16824 "%s: pWDA received NULL", __func__);
16825 VOS_ASSERT(0);
16826 goto error;
16827 }
16828
16829 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16830 if (NULL == pMac)
16831 {
16832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16833 "%s:pMac is NULL", __func__);
16834 VOS_ASSERT(0);
16835 goto error;
16836 }
16837
16838 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16839
16840 if (pMac->sme.pEXTScanIndCb)
16841 {
16842 pMac->sme.pEXTScanIndCb(pCallbackContext,
16843 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16844 pEventData);
16845 }
16846 else
16847 {
16848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16849 "%s:HDD callback is null", __func__);
16850 VOS_ASSERT(0);
16851 }
16852
16853
16854error:
16855
16856 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16857 {
16858 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16859 }
16860 if (pWdaParams->wdaMsgParam != NULL)
16861 {
16862 vos_mem_free(pWdaParams->wdaMsgParam);
16863 }
16864 vos_mem_free(pWdaParams) ;
16865
16866 return;
16867}
16868
16869/*==========================================================================
16870 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16871
16872 DESCRIPTION
16873 API to send EXTScan Get Capabilities Response to HDD
16874
16875 PARAMETERS
16876 pEventData: Response from FW
16877 pUserData:
16878===========================================================================*/
16879void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16880{
16881 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16882 tWDA_CbContext *pWDA = NULL;
16883 void *pCallbackContext;
16884 tpAniSirGlobal pMac;
16885
16886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16887 "%s:", __func__);
16888 if (NULL == pWdaParams)
16889 {
16890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16891 "%s: pWdaParams received NULL", __func__);
16892 VOS_ASSERT(0);
16893 return;
16894 }
16895
16896 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16897
16898 if (NULL == pWDA)
16899 {
16900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16901 "%s: pWDA received NULL", __func__);
16902 VOS_ASSERT(0);
16903 goto error;
16904 }
16905
16906 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16907 if (NULL == pMac)
16908 {
16909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16910 "%s:pMac is NULL", __func__);
16911 VOS_ASSERT(0);
16912 goto error;
16913 }
16914
16915 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16916
16917 if (pMac->sme.pEXTScanIndCb)
16918 {
16919 pMac->sme.pEXTScanIndCb(pCallbackContext,
16920 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16921 pEventData);
16922 }
16923 else
16924 {
16925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16926 "%s:HDD callback is null", __func__);
16927 VOS_ASSERT(0);
16928 }
16929
16930
16931error:
16932
16933 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16934 {
16935 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16936 }
16937 if (pWdaParams->wdaMsgParam != NULL)
16938 {
16939 vos_mem_free(pWdaParams->wdaMsgParam);
16940 }
16941 vos_mem_free(pWdaParams) ;
16942
16943 return;
16944}
16945
16946/*==========================================================================
16947 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16948
16949 DESCRIPTION
16950 API to send EXTScan Set BSSID Hotlist Response to HDD
16951
16952 PARAMETERS
16953 pEventData: Response from FW
16954 pUserData:
16955===========================================================================*/
16956void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16957{
16958 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16959 tWDA_CbContext *pWDA = NULL;
16960 void *pCallbackContext;
16961 tpAniSirGlobal pMac;
16962
16963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16964 "%s: ", __func__);
16965 if (NULL == pWdaParams)
16966 {
16967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16968 "%s: pWdaParams received NULL", __func__);
16969 VOS_ASSERT(0) ;
16970 return;
16971 }
16972
16973 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16974
16975 if (NULL == pWDA)
16976 {
16977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16978 "%s: pWDA received NULL", __func__);
16979 VOS_ASSERT(0);
16980 goto error;
16981 }
16982
16983 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16984 if (NULL == pMac)
16985 {
16986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16987 "%s:pMac is NULL", __func__);
16988 VOS_ASSERT(0);
16989 goto error;
16990 }
16991
16992 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16993
16994 if (pMac->sme.pEXTScanIndCb)
16995 {
16996 pMac->sme.pEXTScanIndCb(pCallbackContext,
16997 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16998 pEventData);
16999 }
17000 else
17001 {
17002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17003 "%s:HDD callback is null", __func__);
17004 VOS_ASSERT(0);
17005 }
17006
17007
17008error:
17009
17010 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17011 {
17012 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17013 }
17014 if (pWdaParams->wdaMsgParam != NULL)
17015 {
17016 vos_mem_free(pWdaParams->wdaMsgParam);
17017 }
17018 vos_mem_free(pWdaParams) ;
17019
17020 return;
17021}
17022
17023/*==========================================================================
17024 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
17025
17026 DESCRIPTION
17027 API to send EXTScan ReSet BSSID Hotlist Response to HDD
17028
17029 PARAMETERS
17030 pEventData: Response from FW
17031 pUserData:
17032===========================================================================*/
17033void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
17034{
17035 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17036 tWDA_CbContext *pWDA = NULL;
17037 void *pCallbackContext;
17038 tpAniSirGlobal pMac;
17039
17040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17041 "%s:", __func__);
17042 if (NULL == pWdaParams)
17043 {
17044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17045 "%s: pWdaParams received NULL", __func__);
17046 VOS_ASSERT(0) ;
17047 return;
17048 }
17049
17050 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17051
17052 if (NULL == pWDA)
17053 {
17054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17055 "%s: pWDA received NULL", __func__);
17056 VOS_ASSERT(0);
17057 goto error;
17058 }
17059
17060 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17061 if (NULL == pMac)
17062 {
17063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17064 "%s:pMac is NULL", __func__);
17065 VOS_ASSERT(0);
17066 goto error;
17067 }
17068
17069 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17070
17071 if (pMac->sme.pEXTScanIndCb)
17072 {
17073 pMac->sme.pEXTScanIndCb(pCallbackContext,
17074 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
17075 pEventData);
17076 }
17077 else
17078 {
17079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17080 "%s:HDD callback is null", __func__);
17081 VOS_ASSERT(0);
17082 }
17083
17084
17085error:
17086
17087 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17088 {
17089 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17090 }
17091 if (pWdaParams->wdaMsgParam != NULL)
17092 {
17093 vos_mem_free(pWdaParams->wdaMsgParam);
17094 }
17095 vos_mem_free(pWdaParams) ;
17096
17097 return;
17098}
17099
17100/*==========================================================================
17101 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
17102
17103 DESCRIPTION
17104 API to send EXTScan Set Significant RSSI Change RSP to HDD
17105
17106 PARAMETERS
17107 pEventData: Response from FW
17108 pUserData:
17109===========================================================================*/
17110void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
17111{
17112 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17113 tWDA_CbContext *pWDA = NULL;
17114 void *pCallbackContext;
17115 tpAniSirGlobal pMac;
17116
17117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17118 "%s:", __func__);
17119 if (NULL == pWdaParams)
17120 {
17121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17122 "%s: pWdaParams received NULL", __func__);
17123 VOS_ASSERT(0) ;
17124 return;
17125 }
17126
17127 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17128
17129 if (NULL == pWDA)
17130 {
17131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17132 "%s: pWDA received NULL", __func__);
17133 VOS_ASSERT(0);
17134 goto error;
17135 }
17136
17137 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17138 if (NULL == pMac)
17139 {
17140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17141 "%s:pMac is NULL", __func__);
17142 VOS_ASSERT(0);
17143 goto error;
17144 }
17145
17146 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17147
17148 if (pMac->sme.pEXTScanIndCb)
17149 {
17150 pMac->sme.pEXTScanIndCb(pCallbackContext,
17151 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
17152 pEventData);
17153 }
17154 else
17155 {
17156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17157 "%s:HDD callback is null", __func__);
17158 VOS_ASSERT(0);
17159 }
17160
17161
17162error:
17163
17164 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17165 {
17166 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17167 }
17168 if (pWdaParams->wdaMsgParam != NULL)
17169 {
17170 vos_mem_free(pWdaParams->wdaMsgParam);
17171 }
17172 vos_mem_free(pWdaParams) ;
17173
17174 return;
17175}
17176
17177/*==========================================================================
17178 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
17179
17180 DESCRIPTION
17181 API to send EXTScan Set Significant RSSI Change RSP to HDD
17182
17183 PARAMETERS
17184 pEventData: Response from FW
17185 pUserData:
17186===========================================================================*/
17187void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
17188 void* pUserData)
17189{
17190 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17191 tWDA_CbContext *pWDA = NULL;
17192 void *pCallbackContext;
17193 tpAniSirGlobal pMac;
17194
17195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17196 "%s:", __func__);
17197 if (NULL == pWdaParams)
17198 {
17199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17200 "%s: pWdaParams received NULL", __func__);
17201 VOS_ASSERT(0) ;
17202 return;
17203 }
17204
17205 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17206
17207 if (NULL == pWDA)
17208 {
17209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17210 "%s: pWDA received NULL", __func__);
17211 VOS_ASSERT(0);
17212 goto error;
17213 }
17214
17215 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17216 if (NULL == pMac)
17217 {
17218 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17219 "%s:pMac is NULL", __func__);
17220 VOS_ASSERT(0);
17221 goto error;
17222 }
17223
17224 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17225
17226 if (pMac->sme.pEXTScanIndCb)
17227 {
17228 pMac->sme.pEXTScanIndCb(pCallbackContext,
17229 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
17230 pEventData);
17231 }
17232 else
17233 {
17234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17235 "%s:HDD callback is null", __func__);
17236 VOS_ASSERT(0);
17237 }
17238
17239
17240error:
17241
17242 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17243 {
17244 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17245 }
17246 if (pWdaParams->wdaMsgParam != NULL)
17247 {
17248 vos_mem_free(pWdaParams->wdaMsgParam);
17249 }
17250 vos_mem_free(pWdaParams) ;
17251
17252 return;
17253}
17254
17255/*==========================================================================
17256 FUNCTION WDA_ProcessEXTScanStartReq
17257
17258 DESCRIPTION
17259 API to send EXTScan Start Request to WDI
17260
17261 PARAMETERS
17262 pWDA: Pointer to WDA context
17263 wdaRequest: Pointer to EXTScan req parameters
17264===========================================================================*/
17265VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
17266 tSirEXTScanStartReqParams *wdaRequest)
17267{
17268 WDI_Status status = WDI_STATUS_SUCCESS;
17269 tWDA_ReqParams *pWdaParams;
17270
17271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17272 "%s: ", __func__);
17273 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17274 if (NULL == pWdaParams)
17275 {
17276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17277 "%s: VOS MEM Alloc Failure", __func__);
17278 VOS_ASSERT(0);
17279 return VOS_STATUS_E_NOMEM;
17280 }
17281 pWdaParams->pWdaContext = pWDA;
17282 pWdaParams->wdaMsgParam = wdaRequest;
17283 pWdaParams->wdaWdiApiMsgParam = NULL;
17284
17285 status = WDI_EXTScanStartReq((void *)wdaRequest,
17286 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
17287 (void *)pWdaParams);
17288 if (IS_WDI_STATUS_FAILURE(status))
17289 {
17290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17291 "Failure to request. Free all the memory " );
17292 vos_mem_free(pWdaParams->wdaMsgParam);
17293 vos_mem_free(pWdaParams);
17294 }
17295 return CONVERT_WDI2VOS_STATUS(status);
17296}
17297
17298/*==========================================================================
17299 FUNCTION WDA_ProcessEXTScanStopReq
17300
17301 DESCRIPTION
17302 API to send EXTScan Start Request to WDI
17303
17304 PARAMETERS
17305 pWDA: Pointer to WDA context
17306 wdaRequest: Pointer to EXTScan req parameters
17307===========================================================================*/
17308VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
17309 tSirEXTScanStopReqParams *wdaRequest)
17310{
17311 WDI_Status status = WDI_STATUS_SUCCESS;
17312 tWDA_ReqParams *pWdaParams;
17313
17314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17315 "%s:", __func__);
17316 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17317 if (NULL == pWdaParams)
17318 {
17319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17320 "%s: VOS MEM Alloc Failure", __func__);
17321 VOS_ASSERT(0);
17322 return VOS_STATUS_E_NOMEM;
17323 }
17324 pWdaParams->pWdaContext = pWDA;
17325 pWdaParams->wdaMsgParam = wdaRequest;
17326 pWdaParams->wdaWdiApiMsgParam = NULL;
17327
17328 status = WDI_EXTScanStopReq((void *)wdaRequest,
17329 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
17330 (void *)pWdaParams);
17331 if (IS_WDI_STATUS_FAILURE(status))
17332 {
17333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17334 "Failure to request. Free all the memory " );
17335 vos_mem_free(pWdaParams->wdaMsgParam);
17336 vos_mem_free(pWdaParams);
17337 }
17338 return CONVERT_WDI2VOS_STATUS(status);
17339}
17340
17341/*==========================================================================
17342 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
17343
17344 DESCRIPTION
17345 API to send EXTScan Get Cached Results Request to WDI
17346
17347 PARAMETERS
17348 pWDA: Pointer to WDA context
17349 wdaRequest: Pointer to EXTScan req parameters
17350===========================================================================*/
17351VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
17352 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
17353{
17354 WDI_Status status = WDI_STATUS_SUCCESS;
17355 tWDA_ReqParams *pWdaParams;
17356
17357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17358 "%s: ", __func__);
17359 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17360 if (NULL == pWdaParams)
17361 {
17362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17363 "%s: VOS MEM Alloc Failure", __func__);
17364 VOS_ASSERT(0);
17365 return VOS_STATUS_E_NOMEM;
17366 }
17367 pWdaParams->pWdaContext = pWDA;
17368 pWdaParams->wdaMsgParam = wdaRequest;
17369 pWdaParams->wdaWdiApiMsgParam = NULL;
17370
17371 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
17372 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
17373 (void *)pWdaParams);
17374 if (IS_WDI_STATUS_FAILURE(status))
17375 {
17376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17377 "Failure to request. Free all the memory " );
17378 vos_mem_free(pWdaParams->wdaMsgParam);
17379 vos_mem_free(pWdaParams);
17380 }
17381 return CONVERT_WDI2VOS_STATUS(status);
17382}
17383
17384/*==========================================================================
17385 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
17386
17387 DESCRIPTION
17388 API to send EXTScan Get Capabilities Request to WDI
17389
17390 PARAMETERS
17391 pWDA: Pointer to WDA context
17392 wdaRequest: Pointer to EXTScan req parameters
17393===========================================================================*/
17394VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
17395 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
17396{
17397 WDI_Status status = WDI_STATUS_SUCCESS;
17398 tWDA_ReqParams *pWdaParams;
17399
17400 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17401 "%s:", __func__);
17402 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17403 if (NULL == pWdaParams)
17404 {
17405 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17406 "%s: VOS MEM Alloc Failure", __func__);
17407 VOS_ASSERT(0);
17408 return VOS_STATUS_E_NOMEM;
17409 }
17410 pWdaParams->pWdaContext = pWDA;
17411 pWdaParams->wdaMsgParam = wdaRequest;
17412 pWdaParams->wdaWdiApiMsgParam = NULL;
17413
17414 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17415 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17416 (void *)pWdaParams);
17417 if (IS_WDI_STATUS_FAILURE(status))
17418 {
17419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17420 "Failure to request. Free all the memory " );
17421 vos_mem_free(pWdaParams->wdaMsgParam);
17422 vos_mem_free(pWdaParams);
17423 }
17424 return CONVERT_WDI2VOS_STATUS(status);
17425}
17426
17427/*==========================================================================
17428 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17429
17430 DESCRIPTION
17431 API to send Set BSSID Hotlist Request to WDI
17432
17433 PARAMETERS
17434 pWDA: Pointer to WDA context
17435 wdaRequest: Pointer to EXTScan req parameters
17436===========================================================================*/
17437VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17438 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17439{
17440 WDI_Status status = WDI_STATUS_SUCCESS;
17441 tWDA_ReqParams *pWdaParams;
17442
17443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17444 "%s: ", __func__);
17445 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17446 if (NULL == pWdaParams)
17447 {
17448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17449 "%s: VOS MEM Alloc Failure", __func__);
17450 VOS_ASSERT(0);
17451 return VOS_STATUS_E_NOMEM;
17452 }
17453 pWdaParams->pWdaContext = pWDA;
17454 pWdaParams->wdaMsgParam = wdaRequest;
17455 pWdaParams->wdaWdiApiMsgParam = NULL;
17456
17457 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17458 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17459 (void *)pWdaParams);
17460 if (IS_WDI_STATUS_FAILURE(status))
17461 {
17462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17463 "Failure to request. Free all the memory " );
17464 vos_mem_free(pWdaParams->wdaMsgParam);
17465 vos_mem_free(pWdaParams);
17466 }
17467 return CONVERT_WDI2VOS_STATUS(status);
17468}
17469
17470/*==========================================================================
17471 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17472
17473 DESCRIPTION
17474 API to send Reset BSSID Hotlist Request to WDI
17475
17476 PARAMETERS
17477 pWDA: Pointer to WDA context
17478 wdaRequest: Pointer to EXTScan req parameters
17479===========================================================================*/
17480VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17481 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17482{
17483 WDI_Status status = WDI_STATUS_SUCCESS;
17484 tWDA_ReqParams *pWdaParams;
17485
17486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17487 "%s:", __func__);
17488 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17489 if (NULL == pWdaParams)
17490 {
17491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17492 "%s: VOS MEM Alloc Failure", __func__);
17493 VOS_ASSERT(0);
17494 return VOS_STATUS_E_NOMEM;
17495 }
17496 pWdaParams->pWdaContext = pWDA;
17497 pWdaParams->wdaMsgParam = wdaRequest;
17498 pWdaParams->wdaWdiApiMsgParam = NULL;
17499
17500 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17501 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17502 (void *)pWdaParams);
17503 if (IS_WDI_STATUS_FAILURE(status))
17504 {
17505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17506 "Failure to request. Free all the memory " );
17507 vos_mem_free(pWdaParams->wdaMsgParam);
17508 vos_mem_free(pWdaParams);
17509 }
17510 return CONVERT_WDI2VOS_STATUS(status);
17511}
17512
17513/*==========================================================================
17514 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17515
17516 DESCRIPTION
17517 API to send Set Significant RSSI Change Request to WDI
17518
17519 PARAMETERS
17520 pWDA: Pointer to WDA context
17521 wdaRequest: Pointer to EXTScan req parameters
17522===========================================================================*/
17523VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17524 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17525{
17526 WDI_Status status = WDI_STATUS_SUCCESS;
17527 tWDA_ReqParams *pWdaParams;
17528
17529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17530 "%s: ", __func__);
17531 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17532 if (NULL == pWdaParams)
17533 {
17534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17535 "%s: VOS MEM Alloc Failure", __func__);
17536 VOS_ASSERT(0);
17537 return VOS_STATUS_E_NOMEM;
17538 }
17539 pWdaParams->pWdaContext = pWDA;
17540 pWdaParams->wdaMsgParam = wdaRequest;
17541 pWdaParams->wdaWdiApiMsgParam = NULL;
17542
17543 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17544 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17545 (void *)pWdaParams);
17546 if (IS_WDI_STATUS_FAILURE(status))
17547 {
17548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17549 "Failure to request. Free all the memory " );
17550 vos_mem_free(pWdaParams->wdaMsgParam);
17551 vos_mem_free(pWdaParams);
17552 }
17553 return CONVERT_WDI2VOS_STATUS(status);
17554}
17555
17556/*==========================================================================
17557 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17558
17559 DESCRIPTION
17560 API to send Reset Significant RSSI Change Request to WDI
17561
17562 PARAMETERS
17563 pWDA: Pointer to WDA context
17564 wdaRequest: Pointer to EXTScan req parameters
17565===========================================================================*/
17566VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17567 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17568{
17569 WDI_Status status = WDI_STATUS_SUCCESS;
17570 tWDA_ReqParams *pWdaParams;
17571
17572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17573 "%s:", __func__);
17574 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17575 if (NULL == pWdaParams)
17576 {
17577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17578 "%s: VOS MEM Alloc Failure", __func__);
17579 VOS_ASSERT(0);
17580 return VOS_STATUS_E_NOMEM;
17581 }
17582 pWdaParams->pWdaContext = pWDA;
17583 pWdaParams->wdaMsgParam = wdaRequest;
17584 pWdaParams->wdaWdiApiMsgParam = NULL;
17585
17586 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17587 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17588 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17589 (void *)pWdaParams);
17590 if (IS_WDI_STATUS_FAILURE(status))
17591 {
17592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17593 "Failure to request. Free all the memory " );
17594 vos_mem_free(pWdaParams->wdaMsgParam);
17595 vos_mem_free(pWdaParams);
17596 }
17597 return CONVERT_WDI2VOS_STATUS(status);
17598}
17599#endif /* WLAN_FEATURE_EXTSCAN */
17600
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17601#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17602
17603/*==========================================================================
17604 FUNCTION WDA_LLStatsSetRspCallback
17605
17606 DESCRIPTION
17607 API to process set link layer statistics response from FW
17608
17609 PARAMETERS
17610 pRsp: Pointer to set link layer statistics response
17611 pUserData: Pointer to user data
17612
17613 RETURN VALUE
17614 NONE
17615
17616===========================================================================*/
17617void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17618{
17619 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17620
17621
17622 if (NULL == pWdaParams)
17623 {
17624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17625 "%s: pWdaParams received NULL", __func__);
17626 VOS_ASSERT(0) ;
17627 return ;
17628 }
17629
17630 /* Do not need to send notification to upper layer
17631 * Just free allocated resources */
17632 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17633 {
17634 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17635 }
17636 if (pWdaParams->wdaMsgParam != NULL)
17637 {
17638 vos_mem_free(pWdaParams->wdaMsgParam);
17639 }
17640 vos_mem_free(pWdaParams) ;
17641
17642 return;
17643}
17644
17645/*==========================================================================
17646 FUNCTION WDA_ProcessLLStatsSetReq
17647
17648 DESCRIPTION
17649 API to send Set Link Layer Stats request to WDI
17650
17651 PARAMETERS
17652 pWDA: Pointer to WDA context
17653 wdaRequest: Pointer to set Link Layer Stats req parameters
17654===========================================================================*/
17655VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17656 tSirLLStatsSetReq *wdaRequest)
17657{
17658 WDI_Status status = WDI_STATUS_SUCCESS;
17659 tWDA_ReqParams *pWdaParams;
17660
17661 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17662 if (NULL == pWdaParams)
17663 {
17664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17665 "%s: VOS MEM Alloc Failure", __func__);
17666 VOS_ASSERT(0);
17667 return VOS_STATUS_E_NOMEM;
17668 }
17669 pWdaParams->pWdaContext = pWDA;
17670 pWdaParams->wdaMsgParam = wdaRequest;
17671 pWdaParams->wdaWdiApiMsgParam = NULL;
17672
17673 status = WDI_LLStatsSetReq((void *)wdaRequest,
17674 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17675 (void *)pWdaParams);
17676 if (IS_WDI_STATUS_FAILURE(status))
17677 {
17678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17679 "Failure to request. Free all the memory " );
17680 vos_mem_free(pWdaParams->wdaMsgParam);
17681 vos_mem_free(pWdaParams);
17682 }
17683 return CONVERT_WDI2VOS_STATUS(status);
17684}
17685
17686/*==========================================================================
17687 FUNCTION WDA_LLStatsGetRspCallback
17688
17689 DESCRIPTION
17690 API to process get link layer statistics response from FW
17691
17692 PARAMETERS
17693 pRsp: Pointer to get link layer statistics response
17694 pUserData: Pointer to user data
17695
17696 RETURN VALUE
17697 NONE
17698
17699===========================================================================*/
17700void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17701{
17702 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17703
17704 if (NULL == pWdaParams)
17705 {
17706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17707 "%s: pWdaParams received NULL", __func__);
17708 VOS_ASSERT(0) ;
17709 return ;
17710 }
17711
17712 /* Do not need to send notification to upper layer
17713 * Just free allocated resources */
17714 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17715 {
17716 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17717 }
17718 if (pWdaParams->wdaMsgParam != NULL)
17719 {
17720 vos_mem_free(pWdaParams->wdaMsgParam);
17721 }
17722 vos_mem_free(pWdaParams) ;
17723
17724 return;
17725}
17726
17727/*==========================================================================
17728 FUNCTION WDA_ProcessLLStatsGetReq
17729
17730 DESCRIPTION
17731 API to send Get Link Layer Stats request to WDI
17732
17733 PARAMETERS
17734 pWDA: Pointer to WDA context
17735 wdaRequest: Pointer to get Link Layer Stats req parameters
17736===========================================================================*/
17737VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17738 tSirLLStatsGetReq *wdaRequest)
17739{
17740 WDI_Status status = WDI_STATUS_SUCCESS;
17741 tWDA_ReqParams *pWdaParams;
17742
17743 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17744 if (NULL == pWdaParams)
17745 {
17746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17747 "%s: VOS MEM Alloc Failure", __func__);
17748 VOS_ASSERT(0);
17749 return VOS_STATUS_E_NOMEM;
17750 }
17751 pWdaParams->pWdaContext = pWDA;
17752 pWdaParams->wdaMsgParam = wdaRequest;
17753 pWdaParams->wdaWdiApiMsgParam = NULL;
17754
17755 status = WDI_LLStatsGetReq((void *) wdaRequest,
17756 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17757 (void *)pWdaParams);
17758 if (IS_WDI_STATUS_FAILURE(status))
17759 {
17760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17761 "Failure to request. Free all the memory " );
17762 vos_mem_free(pWdaParams->wdaMsgParam);
17763 vos_mem_free(pWdaParams);
17764 }
17765 return CONVERT_WDI2VOS_STATUS(status);
17766}
17767
17768/*==========================================================================
17769 FUNCTION WDA_LLStatsClearRspCallback
17770
17771 DESCRIPTION
17772 API to process clear link layer statistics response from FW
17773
17774 PARAMETERS
17775 pRsp: Pointer to clear link layer statistics response
17776 pUserData: Pointer to user data
17777
17778 RETURN VALUE
17779 NONE
17780
17781===========================================================================*/
17782void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17783{
17784 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17785
17786
17787 if (NULL == pWdaParams)
17788 {
17789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17790 "%s: pWdaParams received NULL", __func__);
17791 VOS_ASSERT(0) ;
17792 return ;
17793 }
17794 /* Do not need to send notification to upper layer
17795 * Just free allocated resources */
17796 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17797 {
17798 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17799 }
17800 if (pWdaParams->wdaMsgParam != NULL)
17801 {
17802 vos_mem_free(pWdaParams->wdaMsgParam);
17803 }
17804 vos_mem_free(pWdaParams) ;
17805 return;
17806}
17807
17808/*==========================================================================
17809 FUNCTION WDA_ProcessLLStatsClearReq
17810
17811 DESCRIPTION
17812 API to send Clear Link Layer Stats request to WDI
17813
17814 PARAMETERS
17815 pWDA: Pointer to WDA context
17816 wdaRequest: Pointer to earLink Layer Stats req
17817===========================================================================*/
17818VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17819 tSirLLStatsClearReq *wdaRequest)
17820{
17821 WDI_Status status = WDI_STATUS_SUCCESS;
17822 tWDA_ReqParams *pWdaParams;
17823
17824 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17825 if (NULL == pWdaParams)
17826 {
17827 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17828 "%s: VOS MEM Alloc Failure", __func__);
17829 VOS_ASSERT(0);
17830 return VOS_STATUS_E_NOMEM;
17831 }
17832 pWdaParams->pWdaContext = pWDA;
17833 pWdaParams->wdaMsgParam = wdaRequest;
17834 pWdaParams->wdaWdiApiMsgParam = NULL;
17835
17836 status = WDI_LLStatsClearReq((void *) wdaRequest,
17837 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17838 (void *)pWdaParams);
17839 if (IS_WDI_STATUS_FAILURE(status))
17840 {
17841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17842 "Failure to request. Free all the memory " );
17843 vos_mem_free(pWdaParams->wdaMsgParam);
17844 vos_mem_free(pWdaParams);
17845 }
17846 return CONVERT_WDI2VOS_STATUS(status);
17847}
17848
17849#endif /* WLAN_FEATURE_LINK_LAYER_STATS */